Skip to content

Conversation

@seawinde
Copy link
Contributor

@seawinde seawinde commented Mar 19, 2025

What problem does this PR solve?

Optimize explain info is as following

|                                                                                     
| ========== MATERIALIZATIONS ==========                                              
|                                                                                     
| MaterializedView                                                                    
| MaterializedViewRewriteSuccessAndChose:                                             
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv3 chose     
|                                                                                     
| MaterializedViewRewriteSuccessButNotChose:                                          
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv4 not chose 
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv2 not chose 
|                                                                                     
| MaterializedViewRewriteFail:                                                        
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv1 fail      
|   FailInfo: View struct info is invalid, Predicate compensate fail                  
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv fail       
|   FailInfo: View struct info is invalid                                             
|                                                                                     
|                                                                                     
| ========== STATISTICS ==========                                                    
| planed with unknown column statistics                                               
+-------------------------------------------------------------------------------------
58 rows in set (0.06 sec)

Optimize explain memo plan info is as following:

| ========== MATERIALIZATIONS ==========                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedView                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| MaterializedViewRewriteSuccessAndChose:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv3 chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedViewRewriteSuccessButNotChose:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv4 not chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv2 not chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedViewRewriteFail:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv1 fail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|   FailInfo: View struct info is invalid:view plan is LogicalResultSink[225] ( outputExprs=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum_total#25] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| +--LogicalAggregate[223] ( groupByExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2], outputExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum(o_totalprice#19) AS `sum_total`#25], hasRepeat=false )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|    +--LogicalProject[221] ( distinct=false, projects=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, o_totalprice#19] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|       +--LogicalJoin[219] ( type=LEFT_OUTER_JOIN, markJoinSlotReference=Optional.empty, hashJoinConjuncts=[(l_orderkey#0 = o_orderkey#16), (l_shipdate#10 = o_orderdate#20)], otherJoinConjuncts=[], markJoinConjuncts=[] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|          |--LogicalProject[212] ( distinct=false, projects=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|          |  +--LogicalFilter[210] ( predicates=(l_orderkey#0 = 1) )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|          |     +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.lineitem_partition, indexName=<index_not_selected>, selectedIndexId=1749786446788, preAgg=ON, operativeCol=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|          +--LogicalProject[216] ( distinct=false, projects=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|             +--LogicalFilter[214] ( predicates=(o_orderkey#16 = 1) )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.orders_partition, indexName=<index_not_selected>, selectedIndexId=1749786446763, preAgg=ON, operativeCol=[o_orderkey#16, o_totalprice#19, o_orderdate#20] ), Predicate compensate fail:query predicates = Predicates ( pulledUpPredicates=[] ),                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|  query equivalenceClass = EquivalenceClass{equivalenceSlotMap={}},                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| view predicates = Predicates ( pulledUpPredicates=[] ),                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|  query equivalenceClass = EquivalenceClass{equivalenceSlotMap={}}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| comparisonResult = valid: true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|  viewExpressions: [(l_orderkey#0 = 1)]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|  queryExpressions :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|  viewNoNullableSlot :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| queryAllPulledUpExpressions :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv fail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|   FailInfo: View struct info is invalid:view plan is LogicalResultSink[93] ( outputExprs=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum_total#25] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| +--LogicalAggregate[91] ( groupByExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2], outputExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum(o_totalprice#19) AS `sum_total`#25], hasRepeat=false )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|    +--LogicalProject[89] ( distinct=false, projects=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, o_totalprice#19] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|       +--LogicalJoin[87] ( type=LEFT_OUTER_JOIN, markJoinSlotReference=Optional.empty, hashJoinConjuncts=[(l_orderkey#0 = o_orderkey#16), (l_shipdate#10 = o_orderdate#20)], otherJoinConjuncts=[], markJoinConjuncts=[] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|          |--LogicalProject[83] ( distinct=false, projects=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|          |  +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.lineitem_partition, indexName=<index_not_selected>, selectedIndexId=1749786446788, preAgg=ON, operativeCol=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|          +--LogicalProject[84] ( distinct=false, projects=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|             +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.orders_partition, indexName=<index_not_selected>, selectedIndexId=1749786446763, preAgg=ON, operativeCol=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
535 rows in set (0.07 sec)

Issue Number: close #xxx

Related PR: #xxx

Problem Summary:

Release note

None

Check List (For Author)

  • Test

    • Regression test
    • Unit Test
    • Manual test (add detailed scripts or steps below)
    • No need to test or manual test. Explain why:
      • This is a refactor/code format and no logic has been changed.
      • Previous test can cover this change.
      • No code files have been changed.
      • Other reason
  • Behavior changed:

    • No.
    • Yes.
  • Does this need documentation?

    • No.
    • Yes.

Check List (For Reviewer who merge this PR)

  • Confirm the release note
  • Confirm test cases
  • Confirm document
  • Add branch pick label

@hello-stephen
Copy link
Contributor

Thank you for your contribution to Apache Doris.
Don't know what should be done next? See How to process your PR.

Please clearly describe your PR:

  1. What problem was fixed (it's best to include specific error reporting information). How it was fixed.
  2. Which behaviors were modified. What was the previous behavior, what is it now, why was it modified, and what possible impacts might there be.
  3. What features were added. Why was this function added?
  4. Which code was refactored and why was this part of the code refactored?
  5. Which functions were optimized and what is the difference before and after the optimization?

@seawinde
Copy link
Contributor Author

run buildall

@doris-robot
Copy link

TPC-H: Total hot run time: 32547 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpch-tools
Tpch sf100 test result on commit 94842686482533fd8126468a785c443914acda46, data reload: false

------ Round 1 ----------------------------------
q1	24410	5029	4996	4996
q2	2044	302	173	173
q3	10397	1261	695	695
q4	10232	996	535	535
q5	7536	2468	2403	2403
q6	191	169	134	134
q7	918	745	603	603
q8	9320	1302	1086	1086
q9	4979	4892	4955	4892
q10	6798	2313	1874	1874
q11	470	272	238	238
q12	342	344	231	231
q13	17794	3670	3085	3085
q14	234	229	216	216
q15	534	476	488	476
q16	634	620	583	583
q17	548	848	337	337
q18	7354	6609	6328	6328
q19	1206	953	533	533
q20	322	331	205	205
q21	2752	2133	1914	1914
q22	1069	1035	1010	1010
Total cold run time: 110084 ms
Total hot run time: 32547 ms

----- Round 2, with runtime_filter_mode=off -----
q1	5102	5079	5092	5079
q2	231	342	225	225
q3	2166	2657	2285	2285
q4	1427	1804	1360	1360
q5	4226	4093	4486	4093
q6	210	163	126	126
q7	2026	1946	1738	1738
q8	2602	2544	2527	2527
q9	7231	7187	7307	7187
q10	2972	3190	2773	2773
q11	631	501	502	501
q12	683	742	597	597
q13	3556	3893	3258	3258
q14	268	291	279	279
q15	511	486	465	465
q16	641	696	658	658
q17	1108	1574	1325	1325
q18	7835	7502	7566	7502
q19	790	833	948	833
q20	2028	2009	1857	1857
q21	5345	4821	4595	4595
q22	1080	1055	990	990
Total cold run time: 52669 ms
Total hot run time: 50253 ms

@doris-robot
Copy link

TPC-DS: Total hot run time: 185390 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpcds-tools
TPC-DS sf100 test result on commit 94842686482533fd8126468a785c443914acda46, data reload: false

query1	1013	475	455	455
query2	6526	1970	1942	1942
query3	6804	215	215	215
query4	26324	23494	23259	23259
query5	4350	649	518	518
query6	308	201	190	190
query7	4608	510	293	293
query8	300	243	238	238
query9	8592	2611	2617	2611
query10	457	316	255	255
query11	15340	15264	14879	14879
query12	159	114	107	107
query13	1659	530	406	406
query14	9418	6560	6747	6560
query15	199	182	175	175
query16	7708	628	460	460
query17	1184	705	567	567
query18	1990	399	306	306
query19	187	176	150	150
query20	114	119	113	113
query21	207	118	103	103
query22	4361	4323	4228	4228
query23	33888	32910	32966	32910
query24	7689	2352	2371	2352
query25	502	447	391	391
query26	1235	266	154	154
query27	2118	491	329	329
query28	3884	2418	2399	2399
query29	708	574	419	419
query30	285	217	188	188
query31	944	873	775	775
query32	75	65	69	65
query33	594	350	295	295
query34	783	847	493	493
query35	801	830	720	720
query36	938	1006	869	869
query37	120	106	73	73
query38	4144	4162	4061	4061
query39	1477	1413	1389	1389
query40	212	116	100	100
query41	55	49	54	49
query42	113	101	102	101
query43	500	487	479	479
query44	1263	772	763	763
query45	172	166	201	166
query46	827	1024	608	608
query47	1777	1813	1736	1736
query48	383	413	325	325
query49	771	499	415	415
query50	694	726	394	394
query51	4161	4227	4099	4099
query52	104	100	94	94
query53	223	264	187	187
query54	505	494	409	409
query55	81	77	75	75
query56	253	257	255	255
query57	1134	1138	1077	1077
query58	247	248	243	243
query59	2692	2904	2787	2787
query60	279	271	254	254
query61	123	119	118	118
query62	805	757	657	657
query63	221	191	183	183
query64	4244	1045	667	667
query65	4407	4289	4348	4289
query66	1066	404	290	290
query67	15710	15550	15360	15360
query68	6484	855	493	493
query69	478	299	269	269
query70	1180	1122	1101	1101
query71	394	291	254	254
query72	5546	3515	3741	3515
query73	752	730	349	349
query74	9171	9101	8769	8769
query75	3179	3191	2716	2716
query76	3180	1180	760	760
query77	469	374	305	305
query78	9951	10141	9324	9324
query79	1452	813	587	587
query80	690	533	432	432
query81	496	256	221	221
query82	195	125	91	91
query83	183	171	153	153
query84	243	96	75	75
query85	746	354	308	308
query86	369	279	278	278
query87	4546	4497	4288	4288
query88	2839	2222	2203	2203
query89	380	315	280	280
query90	1948	212	205	205
query91	136	141	111	111
query92	81	61	58	58
query93	1326	1047	589	589
query94	673	398	304	304
query95	354	366	255	255
query96	484	561	270	270
query97	3258	3387	3266	3266
query98	216	205	205	205
query99	1297	1420	1264	1264
Total cold run time: 267711 ms
Total hot run time: 185390 ms

@doris-robot
Copy link

ClickBench: Total hot run time: 31.51 s
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/clickbench-tools
ClickBench test result on commit 94842686482533fd8126468a785c443914acda46, data reload: false

query1	0.04	0.04	0.04
query2	0.12	0.11	0.10
query3	0.24	0.19	0.19
query4	1.59	0.19	0.19
query5	0.59	0.58	0.59
query6	1.20	0.71	0.71
query7	0.02	0.02	0.01
query8	0.04	0.04	0.04
query9	0.59	0.53	0.53
query10	0.57	0.61	0.57
query11	0.15	0.11	0.10
query12	0.14	0.11	0.12
query13	0.61	0.61	0.61
query14	2.74	2.69	2.80
query15	0.93	0.85	0.85
query16	0.40	0.39	0.38
query17	1.06	1.00	1.06
query18	0.21	0.20	0.20
query19	1.88	1.95	1.80
query20	0.02	0.01	0.01
query21	15.35	0.87	0.53
query22	0.77	1.04	0.81
query23	14.95	1.36	0.60
query24	6.64	2.00	1.18
query25	0.50	0.43	0.06
query26	0.53	0.16	0.13
query27	0.06	0.05	0.05
query28	9.54	0.86	0.43
query29	12.56	3.99	3.33
query30	0.24	0.09	0.07
query31	2.82	0.57	0.38
query32	3.23	0.54	0.46
query33	2.99	3.01	3.02
query34	15.80	5.13	4.47
query35	4.52	4.51	4.49
query36	0.66	0.50	0.48
query37	0.09	0.06	0.06
query38	0.05	0.04	0.04
query39	0.04	0.02	0.02
query40	0.18	0.14	0.14
query41	0.09	0.02	0.02
query42	0.04	0.02	0.02
query43	0.03	0.04	0.02
Total cold run time: 104.82 s
Total hot run time: 31.51 s

@seawinde seawinde force-pushed the opt_mv_explain_mv_info branch from 9484268 to 1e702b1 Compare April 3, 2025 03:52
@seawinde
Copy link
Contributor Author

seawinde commented Apr 3, 2025

run buildall

@doris-robot
Copy link

TPC-H: Total hot run time: 34297 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpch-tools
Tpch sf100 test result on commit 1e702b12df19637be9940601119cc8317aa2ef9a, data reload: false

------ Round 1 ----------------------------------
q1	26300	5123	4989	4989
q2	2081	286	183	183
q3	10387	1266	721	721
q4	10228	1013	518	518
q5	7541	2427	2359	2359
q6	189	168	134	134
q7	922	757	606	606
q8	9339	1306	1127	1127
q9	6861	5179	5078	5078
q10	6819	2325	1886	1886
q11	488	289	271	271
q12	349	366	220	220
q13	17794	3874	3105	3105
q14	241	224	209	209
q15	528	489	495	489
q16	635	601	577	577
q17	604	885	362	362
q18	7611	7142	7155	7142
q19	2014	975	553	553
q20	336	341	227	227
q21	4143	3432	2553	2553
q22	1076	1010	988	988
Total cold run time: 116486 ms
Total hot run time: 34297 ms

----- Round 2, with runtime_filter_mode=off -----
q1	5257	5123	5145	5123
q2	248	329	232	232
q3	2171	2827	2294	2294
q4	1448	1892	1480	1480
q5	4504	4404	4380	4380
q6	220	170	126	126
q7	2005	1932	1777	1777
q8	2626	2629	2544	2544
q9	7345	7090	7224	7090
q10	2995	3188	2794	2794
q11	561	523	498	498
q12	665	750	613	613
q13	3538	3879	3427	3427
q14	293	304	264	264
q15	546	482	492	482
q16	670	715	674	674
q17	1187	1571	1429	1429
q18	7834	7623	7524	7524
q19	808	772	956	772
q20	1935	1969	1871	1871
q21	5310	4948	4819	4819
q22	1091	1061	1000	1000
Total cold run time: 53257 ms
Total hot run time: 51213 ms

@doris-robot
Copy link

TPC-DS: Total hot run time: 193342 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpcds-tools
TPC-DS sf100 test result on commit 1e702b12df19637be9940601119cc8317aa2ef9a, data reload: false

query1	1403	1116	1040	1040
query2	6275	1954	1955	1954
query3	11012	4538	4461	4461
query4	55118	25502	22969	22969
query5	5172	488	504	488
query6	366	213	194	194
query7	4966	488	283	283
query8	335	270	245	245
query9	6343	2619	2623	2619
query10	434	332	272	272
query11	15123	15050	14908	14908
query12	160	113	107	107
query13	1103	531	411	411
query14	10169	6343	6452	6343
query15	207	204	185	185
query16	7036	654	508	508
query17	1120	777	619	619
query18	1548	433	320	320
query19	225	220	168	168
query20	129	127	126	126
query21	218	120	102	102
query22	4342	4413	4206	4206
query23	33963	33258	33254	33254
query24	6646	2461	2427	2427
query25	469	466	408	408
query26	679	271	151	151
query27	2219	497	340	340
query28	3115	2459	2474	2459
query29	579	566	432	432
query30	274	229	192	192
query31	879	843	771	771
query32	75	64	61	61
query33	461	367	349	349
query34	769	865	566	566
query35	803	852	764	764
query36	956	1000	910	910
query37	120	105	77	77
query38	4120	4443	4116	4116
query39	1519	1433	1470	1433
query40	224	119	111	111
query41	58	56	51	51
query42	122	109	110	109
query43	508	508	486	486
query44	1381	838	824	824
query45	177	181	168	168
query46	861	1039	658	658
query47	1848	1922	1758	1758
query48	389	415	325	325
query49	683	517	434	434
query50	692	714	408	408
query51	4291	4337	4257	4257
query52	112	110	101	101
query53	237	268	191	191
query54	597	603	524	524
query55	83	84	90	84
query56	319	323	297	297
query57	1139	1184	1119	1119
query58	276	274	259	259
query59	2699	2894	2773	2773
query60	338	335	324	324
query61	143	129	124	124
query62	727	777	687	687
query63	231	197	197	197
query64	1501	1136	737	737
query65	4466	4431	4300	4300
query66	716	408	308	308
query67	16029	15700	15295	15295
query68	7750	880	526	526
query69	589	300	269	269
query70	1176	1131	1094	1094
query71	508	320	301	301
query72	5998	4909	5014	4909
query73	1325	706	349	349
query74	9005	9010	9042	9010
query75	3800	3254	2717	2717
query76	4201	1207	756	756
query77	619	385	289	289
query78	10193	10219	9322	9322
query79	2462	820	572	572
query80	632	582	452	452
query81	490	258	218	218
query82	560	135	98	98
query83	255	249	237	237
query84	298	104	91	91
query85	810	354	329	329
query86	407	286	298	286
query87	4451	4496	4376	4376
query88	3506	2263	2252	2252
query89	406	313	282	282
query90	1748	215	220	215
query91	228	138	114	114
query92	77	59	54	54
query93	2334	933	585	585
query94	659	405	314	314
query95	374	300	284	284
query96	493	574	276	276
query97	3171	3245	3127	3127
query98	229	202	201	201
query99	1412	1380	1290	1290
Total cold run time: 301463 ms
Total hot run time: 193342 ms

@doris-robot
Copy link

ClickBench: Total hot run time: 31 s
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/clickbench-tools
ClickBench test result on commit 1e702b12df19637be9940601119cc8317aa2ef9a, data reload: false

query1	0.04	0.04	0.02
query2	0.12	0.11	0.10
query3	0.26	0.19	0.19
query4	1.59	0.19	0.20
query5	0.59	0.59	0.58
query6	1.17	0.70	0.71
query7	0.02	0.02	0.01
query8	0.04	0.03	0.03
query9	0.57	0.53	0.51
query10	0.61	0.58	0.57
query11	0.15	0.10	0.10
query12	0.15	0.11	0.11
query13	0.61	0.60	0.60
query14	2.67	2.69	2.70
query15	0.94	0.85	0.85
query16	0.39	0.40	0.39
query17	1.02	1.04	1.04
query18	0.20	0.20	0.19
query19	1.92	1.80	2.00
query20	0.01	0.00	0.01
query21	15.35	0.88	0.53
query22	0.76	1.08	0.76
query23	14.94	1.37	0.63
query24	7.51	1.25	0.65
query25	0.51	0.24	0.06
query26	0.61	0.16	0.13
query27	0.05	0.05	0.05
query28	9.53	0.89	0.44
query29	12.55	3.94	3.33
query30	0.26	0.09	0.07
query31	3.03	0.60	0.39
query32	3.52	0.55	0.47
query33	3.00	3.08	3.12
query34	15.76	5.08	4.50
query35	4.50	4.46	4.49
query36	0.67	0.50	0.48
query37	0.09	0.07	0.06
query38	0.05	0.04	0.04
query39	0.03	0.02	0.02
query40	0.16	0.14	0.12
query41	0.08	0.03	0.02
query42	0.03	0.02	0.02
query43	0.04	0.03	0.02
Total cold run time: 106.1 s
Total hot run time: 31 s

@seawinde
Copy link
Contributor Author

run buildall

@doris-robot
Copy link

TPC-H: Total hot run time: 33820 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpch-tools
Tpch sf100 test result on commit a6711c62a536eb79a45126c53ea7861e0e23e631, data reload: false

------ Round 1 ----------------------------------
q1	25844	5098	5064	5064
q2	2066	285	190	190
q3	10402	1246	705	705
q4	10230	995	533	533
q5	7529	2354	2357	2354
q6	187	167	138	138
q7	918	760	605	605
q8	9313	1285	1035	1035
q9	6835	5061	5060	5060
q10	6820	2303	1886	1886
q11	478	292	274	274
q12	353	353	233	233
q13	17757	3722	3112	3112
q14	246	227	219	219
q15	518	478	489	478
q16	448	451	406	406
q17	575	861	360	360
q18	7512	7173	6976	6976
q19	1223	969	542	542
q20	334	345	226	226
q21	3953	3311	2449	2449
q22	1040	978	975	975
Total cold run time: 114581 ms
Total hot run time: 33820 ms

----- Round 2, with runtime_filter_mode=off -----
q1	5140	5103	5120	5103
q2	238	327	237	237
q3	2145	2635	2281	2281
q4	1432	1859	1365	1365
q5	4488	4385	4485	4385
q6	218	172	130	130
q7	1991	1944	1771	1771
q8	2631	2604	2583	2583
q9	7351	7242	7052	7052
q10	2988	3203	2764	2764
q11	579	530	489	489
q12	684	774	622	622
q13	3591	3958	3299	3299
q14	302	296	305	296
q15	526	477	485	477
q16	465	503	458	458
q17	1163	1606	1377	1377
q18	7749	7617	7490	7490
q19	811	803	898	803
q20	2019	1992	1841	1841
q21	5224	4905	4806	4806
q22	1100	1079	1009	1009
Total cold run time: 52835 ms
Total hot run time: 50638 ms

@doris-robot
Copy link

TPC-DS: Total hot run time: 191394 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpcds-tools
TPC-DS sf100 test result on commit a6711c62a536eb79a45126c53ea7861e0e23e631, data reload: false

query1	1389	1094	1050	1050
query2	6379	1790	1786	1786
query3	10994	4412	4487	4412
query4	53206	26126	22966	22966
query5	5176	510	460	460
query6	347	207	206	206
query7	4927	510	282	282
query8	328	241	264	241
query9	5729	2536	2555	2536
query10	424	319	255	255
query11	14948	14975	14788	14788
query12	170	107	100	100
query13	1038	499	376	376
query14	10023	6177	6238	6177
query15	197	189	179	179
query16	7086	667	498	498
query17	1097	767	582	582
query18	1546	417	307	307
query19	215	205	166	166
query20	124	131	118	118
query21	206	129	109	109
query22	4302	4325	4210	4210
query23	34021	33423	33410	33410
query24	6644	2413	2434	2413
query25	498	475	419	419
query26	675	280	151	151
query27	2297	506	343	343
query28	2876	2115	2121	2115
query29	558	557	427	427
query30	271	228	195	195
query31	857	843	783	783
query32	71	63	63	63
query33	470	373	290	290
query34	765	878	515	515
query35	816	857	766	766
query36	925	1021	885	885
query37	113	102	77	77
query38	4198	4159	4163	4159
query39	1531	1440	1421	1421
query40	207	132	108	108
query41	55	56	52	52
query42	134	111	105	105
query43	482	476	482	476
query44	1332	798	802	798
query45	189	182	168	168
query46	842	1028	635	635
query47	1836	1887	1812	1812
query48	388	401	315	315
query49	693	509	452	452
query50	650	703	406	406
query51	4275	4225	4183	4183
query52	116	110	109	109
query53	241	273	188	188
query54	588	599	511	511
query55	88	81	78	78
query56	304	298	304	298
query57	1134	1184	1113	1113
query58	268	266	266	266
query59	2755	2706	2655	2655
query60	344	319	301	301
query61	147	124	130	124
query62	736	746	686	686
query63	235	191	202	191
query64	1568	1129	796	796
query65	4450	4389	4204	4204
query66	751	414	315	315
query67	15762	15677	15383	15383
query68	7290	872	512	512
query69	584	292	262	262
query70	1212	1090	1110	1090
query71	447	320	298	298
query72	5841	4770	4929	4770
query73	1147	695	343	343
query74	9265	9198	8554	8554
query75	3376	3177	2717	2717
query76	3903	1195	785	785
query77	551	382	279	279
query78	10026	10241	9270	9270
query79	2206	870	562	562
query80	592	505	440	440
query81	490	259	214	214
query82	424	132	100	100
query83	252	242	239	239
query84	298	119	86	86
query85	798	353	314	314
query86	399	315	294	294
query87	4448	4540	4377	4377
query88	3294	2249	2207	2207
query89	394	314	272	272
query90	1784	204	209	204
query91	142	151	115	115
query92	74	61	65	61
query93	1841	938	569	569
query94	701	418	306	306
query95	372	291	283	283
query96	495	577	277	277
query97	3185	3217	3136	3136
query98	233	204	202	202
query99	1423	1414	1292	1292
Total cold run time: 295494 ms
Total hot run time: 191394 ms

@doris-robot
Copy link

ClickBench: Total hot run time: 29.13 s
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/clickbench-tools
ClickBench test result on commit a6711c62a536eb79a45126c53ea7861e0e23e631, data reload: false

query1	0.04	0.04	0.03
query2	0.11	0.11	0.11
query3	0.25	0.20	0.19
query4	1.60	0.19	0.19
query5	0.58	0.68	0.59
query6	1.18	0.71	0.71
query7	0.03	0.02	0.02
query8	0.04	0.03	0.04
query9	0.58	0.51	0.51
query10	0.55	0.57	0.58
query11	0.16	0.11	0.11
query12	0.15	0.11	0.11
query13	0.61	0.60	0.59
query14	1.14	1.19	1.18
query15	0.86	0.82	0.85
query16	0.39	0.40	0.37
query17	1.03	1.04	1.04
query18	0.21	0.19	0.20
query19	1.86	1.83	1.80
query20	0.01	0.01	0.01
query21	15.40	0.88	0.53
query22	0.74	1.33	0.66
query23	14.84	1.39	0.62
query24	7.31	1.25	0.51
query25	0.50	0.33	0.08
query26	0.55	0.17	0.15
query27	0.05	0.04	0.05
query28	10.06	0.85	0.43
query29	12.82	3.96	3.27
query30	0.25	0.10	0.07
query31	2.81	0.58	0.38
query32	3.23	0.54	0.47
query33	3.05	3.00	3.02
query34	15.69	5.06	4.47
query35	4.48	4.50	4.49
query36	0.65	0.49	0.47
query37	0.08	0.06	0.06
query38	0.05	0.04	0.04
query39	0.03	0.03	0.02
query40	0.16	0.14	0.14
query41	0.08	0.02	0.02
query42	0.04	0.02	0.02
query43	0.04	0.03	0.02
Total cold run time: 104.29 s
Total hot run time: 29.13 s

@seawinde seawinde force-pushed the opt_mv_explain_mv_info branch from a6711c6 to 676cad2 Compare June 13, 2025 06:10
.append(generateIdentifierName(materializationQualifier)).append(" chose, \n"));
} else {
builder.append(" chose: none, \n");
.append(generateIdentifierName(materializationQualifier)).append(" chose \n"));
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

why not " chose\n"

@seawinde
Copy link
Contributor Author

run buildall

@doris-robot
Copy link

TPC-H: Total hot run time: 33905 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpch-tools
Tpch sf100 test result on commit ca191c203337f8453980fe7ed6c65ec1b1690ec7, data reload: false

------ Round 1 ----------------------------------
q1	17612	5183	5075	5075
q2	1946	289	194	194
q3	10360	1302	761	761
q4	10230	1024	507	507
q5	7585	2382	2325	2325
q6	186	163	134	134
q7	918	730	609	609
q8	9300	1250	1081	1081
q9	6765	5001	5052	5001
q10	6827	2302	1936	1936
q11	501	288	277	277
q12	341	351	213	213
q13	17781	3722	3095	3095
q14	239	229	222	222
q15	568	475	479	475
q16	426	437	377	377
q17	616	868	391	391
q18	7865	7192	7124	7124
q19	1788	968	583	583
q20	339	348	222	222
q21	3702	2538	2354	2354
q22	1062	1030	949	949
Total cold run time: 106957 ms
Total hot run time: 33905 ms

----- Round 2, with runtime_filter_mode=off -----
q1	5190	5075	5072	5072
q2	238	317	222	222
q3	2133	2673	2323	2323
q4	1341	1814	1315	1315
q5	4257	4162	4123	4123
q6	202	167	127	127
q7	1925	1793	1642	1642
q8	2482	2488	2377	2377
q9	6862	6801	6775	6775
q10	2898	3096	2659	2659
q11	568	503	481	481
q12	623	778	587	587
q13	3290	3691	3116	3116
q14	267	282	272	272
q15	515	466	468	466
q16	430	460	422	422
q17	1128	1544	1319	1319
q18	7211	7260	7112	7112
q19	784	831	1006	831
q20	1920	1964	1819	1819
q21	4676	4384	4344	4344
q22	1068	1046	996	996
Total cold run time: 50008 ms
Total hot run time: 48400 ms

@doris-robot
Copy link

TPC-DS: Total hot run time: 185336 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpcds-tools
TPC-DS sf100 test result on commit ca191c203337f8453980fe7ed6c65ec1b1690ec7, data reload: false

query1	1014	404	391	391
query2	6542	1873	1812	1812
query3	6742	224	227	224
query4	26434	23233	23043	23043
query5	4520	628	470	470
query6	316	215	206	206
query7	4628	489	280	280
query8	277	229	221	221
query9	8662	2611	2653	2611
query10	482	333	279	279
query11	15539	15062	14837	14837
query12	172	108	110	108
query13	1663	533	437	437
query14	9970	6291	6248	6248
query15	208	204	172	172
query16	7655	625	480	480
query17	1410	768	585	585
query18	2022	402	310	310
query19	230	194	181	181
query20	126	123	117	117
query21	218	128	113	113
query22	4193	4052	4006	4006
query23	34354	33066	33085	33066
query24	8487	2387	2394	2387
query25	512	463	393	393
query26	1228	264	162	162
query27	2706	497	335	335
query28	4291	2131	2112	2112
query29	724	555	439	439
query30	284	215	203	203
query31	917	816	738	738
query32	72	63	64	63
query33	554	371	321	321
query34	792	844	533	533
query35	781	817	697	697
query36	973	965	873	873
query37	122	103	79	79
query38	4086	4092	4098	4092
query39	1460	1414	1383	1383
query40	212	125	106	106
query41	64	59	59	59
query42	120	106	106	106
query43	498	517	482	482
query44	1321	834	835	834
query45	193	186	176	176
query46	833	1002	637	637
query47	1735	1763	1689	1689
query48	398	422	308	308
query49	745	533	414	414
query50	628	700	414	414
query51	4098	4158	4130	4130
query52	106	108	98	98
query53	217	258	185	185
query54	581	565	497	497
query55	86	80	82	80
query56	311	290	281	281
query57	1171	1186	1114	1114
query58	265	265	265	265
query59	2651	2606	2617	2606
query60	320	319	314	314
query61	124	126	143	126
query62	837	733	629	629
query63	219	189	188	188
query64	4226	1015	671	671
query65	4265	4149	4213	4149
query66	1067	403	320	320
query67	15692	15801	15306	15306
query68	8276	932	519	519
query69	459	311	272	272
query70	1210	1077	1049	1049
query71	485	321	308	308
query72	5455	4733	4744	4733
query73	739	631	349	349
query74	8819	9152	8835	8835
query75	3844	3207	2706	2706
query76	3700	1193	749	749
query77	782	372	283	283
query78	10113	10215	9285	9285
query79	3068	821	577	577
query80	675	549	463	463
query81	476	255	227	227
query82	463	127	94	94
query83	303	243	234	234
query84	291	99	88	88
query85	774	338	304	304
query86	337	313	282	282
query87	4425	4465	4338	4338
query88	3433	2275	2265	2265
query89	396	373	293	293
query90	1983	203	215	203
query91	142	139	116	116
query92	75	61	60	60
query93	2269	920	573	573
query94	674	420	273	273
query95	374	290	283	283
query96	493	559	279	279
query97	2766	2733	2620	2620
query98	239	207	202	202
query99	1465	1384	1283	1283
Total cold run time: 277352 ms
Total hot run time: 185336 ms

@doris-robot
Copy link

ClickBench: Total hot run time: 28.91 s
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/clickbench-tools
ClickBench test result on commit ca191c203337f8453980fe7ed6c65ec1b1690ec7, data reload: false

query1	0.03	0.03	0.03
query2	0.07	0.03	0.04
query3	0.23	0.07	0.07
query4	1.61	0.10	0.10
query5	0.43	0.42	0.44
query6	1.14	0.67	0.65
query7	0.02	0.02	0.02
query8	0.05	0.04	0.04
query9	0.60	0.52	0.52
query10	0.58	0.59	0.58
query11	0.15	0.11	0.11
query12	0.15	0.11	0.12
query13	0.62	0.60	0.59
query14	0.79	0.81	0.79
query15	0.88	0.88	0.84
query16	0.39	0.40	0.38
query17	1.02	1.01	1.05
query18	0.22	0.21	0.22
query19	1.93	1.83	1.86
query20	0.02	0.01	0.01
query21	15.39	0.90	0.55
query22	0.77	1.26	0.81
query23	14.70	1.41	0.63
query24	7.52	1.63	0.88
query25	0.47	0.24	0.08
query26	0.67	0.16	0.13
query27	0.05	0.05	0.04
query28	9.52	0.87	0.43
query29	12.54	3.99	3.34
query30	0.26	0.08	0.07
query31	2.82	0.59	0.38
query32	3.22	0.55	0.47
query33	3.06	3.09	3.08
query34	15.74	5.11	4.43
query35	4.52	4.50	4.46
query36	0.68	0.49	0.47
query37	0.08	0.06	0.07
query38	0.05	0.04	0.04
query39	0.03	0.03	0.02
query40	0.17	0.13	0.14
query41	0.09	0.02	0.02
query42	0.04	0.03	0.02
query43	0.04	0.04	0.03
Total cold run time: 103.36 s
Total hot run time: 28.91 s

@github-actions
Copy link
Contributor

PR approved by at least one committer and no changes requested.

@github-actions github-actions bot added approved Indicates a PR has been approved by one committer. reviewed labels Jun 19, 2025
@github-actions
Copy link
Contributor

PR approved by anyone and no changes requested.

@seawinde seawinde force-pushed the opt_mv_explain_mv_info branch from ca191c2 to 6424684 Compare July 23, 2025 02:09
@seawinde
Copy link
Contributor Author

run buildall

@doris-robot
Copy link

TPC-H: Total hot run time: 34135 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpch-tools
Tpch sf100 test result on commit 6424684c6b1f143d29be6a22f83f69aa748d8104, data reload: false

------ Round 1 ----------------------------------
q1	17592	5187	5052	5052
q2	1947	287	185	185
q3	10277	1304	731	731
q4	10223	992	530	530
q5	7484	2361	2333	2333
q6	174	156	126	126
q7	874	758	589	589
q8	9297	1257	1061	1061
q9	6989	5123	5155	5123
q10	6890	2370	1961	1961
q11	490	292	294	292
q12	346	360	213	213
q13	17766	3690	3100	3100
q14	230	226	227	226
q15	536	478	487	478
q16	418	428	379	379
q17	625	868	388	388
q18	7507	7270	7180	7180
q19	1209	937	571	571
q20	352	342	234	234
q21	4016	3193	2402	2402
q22	1055	1073	981	981
Total cold run time: 106297 ms
Total hot run time: 34135 ms

----- Round 2, with runtime_filter_mode=off -----
q1	5181	5114	5077	5077
q2	242	322	219	219
q3	2212	2702	2337	2337
q4	1370	1765	1338	1338
q5	4218	4604	4607	4604
q6	211	170	128	128
q7	1985	2057	1872	1872
q8	2668	2594	2554	2554
q9	7372	7296	7230	7230
q10	3175	3288	2933	2933
q11	565	501	478	478
q12	747	803	632	632
q13	3557	4007	3273	3273
q14	281	304	303	303
q15	522	485	482	482
q16	450	527	449	449
q17	1207	1666	1380	1380
q18	8189	7756	7736	7736
q19	808	872	930	872
q20	1949	1947	1825	1825
q21	4830	4273	4325	4273
q22	1082	1044	967	967
Total cold run time: 52821 ms
Total hot run time: 50962 ms

@doris-robot
Copy link

TPC-DS: Total hot run time: 187272 ms
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/tpcds-tools
TPC-DS sf100 test result on commit 6424684c6b1f143d29be6a22f83f69aa748d8104, data reload: false

query1	995	382	415	382
query2	6516	1658	1699	1658
query3	6739	223	216	216
query4	26155	23750	22990	22990
query5	4345	615	489	489
query6	310	228	201	201
query7	4632	488	295	295
query8	273	241	224	224
query9	8590	2842	2807	2807
query10	454	328	275	275
query11	15842	15143	14754	14754
query12	164	111	103	103
query13	1648	517	413	413
query14	8486	5804	5804	5804
query15	207	184	166	166
query16	7128	647	498	498
query17	1072	745	609	609
query18	1988	421	318	318
query19	194	189	174	174
query20	121	127	114	114
query21	212	126	113	113
query22	4237	4352	4159	4159
query23	34055	33079	32978	32978
query24	8085	2376	2410	2376
query25	580	531	444	444
query26	1229	273	165	165
query27	2758	500	338	338
query28	4352	2212	2177	2177
query29	793	589	489	489
query30	346	224	183	183
query31	904	818	731	731
query32	81	75	68	68
query33	551	386	336	336
query34	790	830	519	519
query35	801	836	751	751
query36	1025	982	939	939
query37	118	101	88	88
query38	4075	4059	4159	4059
query39	1471	1421	1403	1403
query40	220	129	112	112
query41	57	61	53	53
query42	124	107	109	107
query43	506	485	450	450
query44	1314	848	838	838
query45	174	170	164	164
query46	832	1005	630	630
query47	1814	1832	1815	1815
query48	376	424	324	324
query49	733	490	389	389
query50	635	701	403	403
query51	5387	5444	5621	5444
query52	116	105	99	99
query53	230	260	191	191
query54	592	577	523	523
query55	92	86	88	86
query56	315	333	310	310
query57	1175	1196	1149	1149
query58	277	264	273	264
query59	2698	2722	2614	2614
query60	354	335	327	327
query61	137	132	133	132
query62	802	704	678	678
query63	217	191	191	191
query64	4337	1095	733	733
query65	4231	4191	4211	4191
query66	1161	438	359	359
query67	16008	15756	15413	15413
query68	8718	905	557	557
query69	483	324	294	294
query70	1263	1165	1140	1140
query71	458	326	309	309
query72	5799	4699	4881	4699
query73	764	632	345	345
query74	9177	9028	8926	8926
query75	3996	3073	2649	2649
query76	3632	1125	724	724
query77	828	392	316	316
query78	9993	10241	9319	9319
query79	3665	834	568	568
query80	632	597	480	480
query81	454	252	221	221
query82	510	135	111	111
query83	289	264	241	241
query84	303	110	85	85
query85	792	377	333	333
query86	361	327	310	310
query87	4413	4336	4310	4310
query88	2884	2236	2219	2219
query89	444	311	289	289
query90	1921	232	216	216
query91	135	140	111	111
query92	85	69	67	67
query93	2092	953	621	621
query94	727	401	271	271
query95	393	303	310	303
query96	478	587	279	279
query97	2744	2721	2644	2644
query98	234	216	211	211
query99	1427	1412	1309	1309
Total cold run time: 277330 ms
Total hot run time: 187272 ms

@doris-robot
Copy link

ClickBench: Total hot run time: 33.05 s
machine: 'aliyun_ecs.c7a.8xlarge_32C64G'
scripts: https://github.com/apache/doris/tree/master/tools/clickbench-tools
ClickBench test result on commit 6424684c6b1f143d29be6a22f83f69aa748d8104, data reload: false

query1	0.04	0.03	0.03
query2	0.08	0.04	0.04
query3	0.24	0.08	0.07
query4	1.63	0.11	0.10
query5	0.42	0.41	0.40
query6	1.17	0.66	0.67
query7	0.02	0.01	0.02
query8	0.04	0.04	0.03
query9	0.59	0.53	0.51
query10	0.59	0.59	0.58
query11	0.17	0.11	0.11
query12	0.15	0.11	0.11
query13	0.64	0.62	0.60
query14	0.80	0.81	0.84
query15	0.90	0.87	0.88
query16	0.38	0.37	0.40
query17	1.09	1.08	1.07
query18	0.22	0.20	0.20
query19	1.94	1.81	1.82
query20	0.01	0.02	0.02
query21	15.37	0.88	0.54
query22	0.76	1.19	0.78
query23	14.81	1.39	0.63
query24	6.84	1.29	1.27
query25	0.56	0.19	0.08
query26	0.63	0.18	0.14
query27	0.06	0.05	0.05
query28	9.62	0.95	0.43
query29	12.56	3.97	3.25
query30	3.12	3.05	3.00
query31	2.83	0.58	0.38
query32	3.25	0.54	0.46
query33	3.18	3.08	3.12
query34	15.92	5.45	4.91
query35	4.89	4.81	4.92
query36	0.69	0.52	0.49
query37	0.09	0.07	0.07
query38	0.06	0.04	0.04
query39	0.03	0.03	0.03
query40	0.18	0.14	0.14
query41	0.08	0.02	0.03
query42	0.03	0.03	0.02
query43	0.05	0.03	0.03
Total cold run time: 106.73 s
Total hot run time: 33.05 s

@hello-stephen
Copy link
Contributor

FE UT Coverage Report

Increment line coverage 12.50% (1/8) 🎉
Increment coverage report
Complete coverage report

@morrySnow
Copy link
Contributor

run check_coverage

@morrySnow morrySnow merged commit 861a7c5 into apache:master Jul 25, 2025
28 checks passed
w41ter pushed a commit to w41ter/incubator-doris that referenced this pull request Jul 30, 2025
…9256)

### What problem does this PR solve?

Optimize explain info is as following

|                                                                                     
| ========== MATERIALIZATIONS ==========                                              
|                                                                                     
| MaterializedView                                                                    
| MaterializedViewRewriteSuccessAndChose:                                             
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv3 chose     
|                                                                                     
| MaterializedViewRewriteSuccessButNotChose:                                          
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv4 not chose 
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv2 not chose 
|                                                                                     
| MaterializedViewRewriteFail:                                                        
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv1 fail      
|   FailInfo: View struct info is invalid, Predicate compensate fail                  
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv fail       
|   FailInfo: View struct info is invalid                                             
|                                                                                     
|                                                                                     
| ========== STATISTICS ==========                                                    
| planed with unknown column statistics                                               
+-------------------------------------------------------------------------------------
58 rows in set (0.06 sec)

Optimize explain memo plan info is as following:

| ========== MATERIALIZATIONS ==========                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedView                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| MaterializedViewRewriteSuccessAndChose:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv3 chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedViewRewriteSuccessButNotChose:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv4 not chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv2 not chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedViewRewriteFail:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv1 fail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|   FailInfo: View struct info is invalid:view plan is LogicalResultSink[225] ( outputExprs=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum_total#25] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| +--LogicalAggregate[223] ( groupByExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2], outputExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum(o_totalprice#19) AS `sum_total`apache#25], hasRepeat=false )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|    +--LogicalProject[221] ( distinct=false, projects=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, o_totalprice#19] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|       +--LogicalJoin[219] ( type=LEFT_OUTER_JOIN, markJoinSlotReference=Optional.empty, hashJoinConjuncts=[(l_orderkey#0 = o_orderkey#16), (l_shipdate#10 = o_orderdate#20)], otherJoinConjuncts=[], markJoinConjuncts=[] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|          |--LogicalProject[212] ( distinct=false, projects=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|          |  +--LogicalFilter[210] ( predicates=(l_orderkey#0 = 1) )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|          |     +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.lineitem_partition, indexName=<index_not_selected>, selectedIndexId=1749786446788, preAgg=ON, operativeCol=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|          +--LogicalProject[216] ( distinct=false, projects=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|             +--LogicalFilter[214] ( predicates=(o_orderkey#16 = 1) )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.orders_partition, indexName=<index_not_selected>, selectedIndexId=1749786446763, preAgg=ON, operativeCol=[o_orderkey#16, o_totalprice#19, o_orderdate#20] ), Predicate compensate fail:query predicates = Predicates ( pulledUpPredicates=[] ),                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|  query equivalenceClass = EquivalenceClass{equivalenceSlotMap={}},                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| view predicates = Predicates ( pulledUpPredicates=[] ),                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|  query equivalenceClass = EquivalenceClass{equivalenceSlotMap={}}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| comparisonResult = valid: true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|  viewExpressions: [(l_orderkey#0 = 1)]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|  queryExpressions :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|  viewNoNullableSlot :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| queryAllPulledUpExpressions :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv fail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|   FailInfo: View struct info is invalid:view plan is LogicalResultSink[93] ( outputExprs=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum_total#25] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| +--LogicalAggregate[91] ( groupByExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2], outputExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum(o_totalprice#19) AS `sum_total`apache#25], hasRepeat=false )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|    +--LogicalProject[89] ( distinct=false, projects=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, o_totalprice#19] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|       +--LogicalJoin[87] ( type=LEFT_OUTER_JOIN, markJoinSlotReference=Optional.empty, hashJoinConjuncts=[(l_orderkey#0 = o_orderkey#16), (l_shipdate#10 = o_orderdate#20)], otherJoinConjuncts=[], markJoinConjuncts=[] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|          |--LogicalProject[83] ( distinct=false, projects=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|          |  +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.lineitem_partition, indexName=<index_not_selected>, selectedIndexId=1749786446788, preAgg=ON, operativeCol=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|          +--LogicalProject[84] ( distinct=false, projects=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|             +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.orders_partition, indexName=<index_not_selected>, selectedIndexId=1749786446763, preAgg=ON, operativeCol=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
535 rows in set (0.07 sec)
zhiqiang-hhhh pushed a commit to zhiqiang-hhhh/doris that referenced this pull request Aug 4, 2025
…9256)

### What problem does this PR solve?

Optimize explain info is as following

|                                                                                     
| ========== MATERIALIZATIONS ==========                                              
|                                                                                     
| MaterializedView                                                                    
| MaterializedViewRewriteSuccessAndChose:                                             
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv3 chose     
|                                                                                     
| MaterializedViewRewriteSuccessButNotChose:                                          
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv4 not chose 
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv2 not chose 
|                                                                                     
| MaterializedViewRewriteFail:                                                        
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv1 fail      
|   FailInfo: View struct info is invalid, Predicate compensate fail                  
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv fail       
|   FailInfo: View struct info is invalid                                             
|                                                                                     
|                                                                                     
| ========== STATISTICS ==========                                                    
| planed with unknown column statistics                                               
+-------------------------------------------------------------------------------------
58 rows in set (0.06 sec)

Optimize explain memo plan info is as following:

| ========== MATERIALIZATIONS ==========                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedView                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| MaterializedViewRewriteSuccessAndChose:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv3 chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedViewRewriteSuccessButNotChose:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv4 not chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv2 not chose                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| MaterializedViewRewriteFail:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv1 fail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|   FailInfo: View struct info is invalid:view plan is LogicalResultSink[225] ( outputExprs=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum_total#25] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| +--LogicalAggregate[223] ( groupByExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2], outputExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum(o_totalprice#19) AS `sum_total`apache#25], hasRepeat=false )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|    +--LogicalProject[221] ( distinct=false, projects=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, o_totalprice#19] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|       +--LogicalJoin[219] ( type=LEFT_OUTER_JOIN, markJoinSlotReference=Optional.empty, hashJoinConjuncts=[(l_orderkey#0 = o_orderkey#16), (l_shipdate#10 = o_orderdate#20)], otherJoinConjuncts=[], markJoinConjuncts=[] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|          |--LogicalProject[212] ( distinct=false, projects=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|          |  +--LogicalFilter[210] ( predicates=(l_orderkey#0 = 1) )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|          |     +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.lineitem_partition, indexName=<index_not_selected>, selectedIndexId=1749786446788, preAgg=ON, operativeCol=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|          +--LogicalProject[216] ( distinct=false, projects=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|             +--LogicalFilter[214] ( predicates=(o_orderkey#16 = 1) )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.orders_partition, indexName=<index_not_selected>, selectedIndexId=1749786446763, preAgg=ON, operativeCol=[o_orderkey#16, o_totalprice#19, o_orderdate#20] ), Predicate compensate fail:query predicates = Predicates ( pulledUpPredicates=[] ),                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|  query equivalenceClass = EquivalenceClass{equivalenceSlotMap={}},                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| view predicates = Predicates ( pulledUpPredicates=[] ),                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|  query equivalenceClass = EquivalenceClass{equivalenceSlotMap={}}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| comparisonResult = valid: true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|  viewExpressions: [(l_orderkey#0 = 1)]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|  queryExpressions :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|  viewNoNullableSlot :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| queryAllPulledUpExpressions :[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|   internal.regression_test_nereids_rules_p0_mv_availability.partition_mv fail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|   FailInfo: View struct info is invalid:view plan is LogicalResultSink[93] ( outputExprs=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum_total#25] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| +--LogicalAggregate[91] ( groupByExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2], outputExpr=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, sum(o_totalprice#19) AS `sum_total`apache#25], hasRepeat=false )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|    +--LogicalProject[89] ( distinct=false, projects=[l_shipdate#10, o_orderdate#20, l_partkey#1, l_suppkey#2, o_totalprice#19] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|       +--LogicalJoin[87] ( type=LEFT_OUTER_JOIN, markJoinSlotReference=Optional.empty, hashJoinConjuncts=[(l_orderkey#0 = o_orderkey#16), (l_shipdate#10 = o_orderdate#20)], otherJoinConjuncts=[], markJoinConjuncts=[] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|          |--LogicalProject[83] ( distinct=false, projects=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|          |  +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.lineitem_partition, indexName=<index_not_selected>, selectedIndexId=1749786446788, preAgg=ON, operativeCol=[l_orderkey#0, l_partkey#1, l_suppkey#2, l_shipdate#10] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|          +--LogicalProject[84] ( distinct=false, projects=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|             +--LogicalOlapScan ( qualified=internal.regression_test_nereids_rules_p0_mv_availability.orders_partition, indexName=<index_not_selected>, selectedIndexId=1749786446763, preAgg=ON, operativeCol=[o_orderkey#16, o_totalprice#19, o_orderdate#20] )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
535 rows in set (0.07 sec)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

approved Indicates a PR has been approved by one committer. reviewed

Projects

None yet

Development

Successfully merging this pull request may close these issues.

5 participants