This is an automated email from the ASF dual-hosted git repository.

yiguolei pushed a commit to branch branch-4.0
in repository https://gitbox.apache.org/repos/asf/doris.git


The following commit(s) were added to refs/heads/branch-4.0 by this push:
     new 73fb086c878 branch-4.0: [test](nerieds)fix sql cache with mtmv test 
case #58236 (#60956)
73fb086c878 is described below

commit 73fb086c878be44c28d1215eb3d85788d4c8c0f8
Author: github-actions[bot] 
<41898282+github-actions[bot]@users.noreply.github.com>
AuthorDate: Tue Mar 3 17:54:36 2026 +0800

    branch-4.0: [test](nerieds)fix sql cache with mtmv test case #58236 (#60956)
    
    Cherry-picked from #58236
    
    Co-authored-by: zfr95 <[email protected]>
---
 .../nereids_p0/cache/mtmv_with_sql_cache.groovy    | 31 +++++++++++++++++++++-
 .../nereids_p0/cache/mv_with_sql_cache.groovy      |  9 +++++++
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/regression-test/suites/nereids_p0/cache/mtmv_with_sql_cache.groovy 
b/regression-test/suites/nereids_p0/cache/mtmv_with_sql_cache.groovy
index fdcf4dbb131..49e7bd1aaa0 100644
--- a/regression-test/suites/nereids_p0/cache/mtmv_with_sql_cache.groovy
+++ b/regression-test/suites/nereids_p0/cache/mtmv_with_sql_cache.groovy
@@ -184,6 +184,7 @@ suite("mtmv_with_sql_cache") {
                             cur_create_async_partition_mv(dbName, mv_name2, 
mtmv_sql2, "(id)")
                             cur_create_async_partition_mv(dbName, mv_name4, 
mtmv_sql4, "(id)")
                             cur_create_async_partition_mv(dbName, 
nested_mv_name1, nested_mtmv_sql1, "(id)")
+                            sleep(10 * 1000)
 
                             sql "set enable_nereids_planner=true"
                             sql "set enable_fallback_to_original_planner=false"
@@ -220,12 +221,14 @@ suite("mtmv_with_sql_cache") {
 
                             // rename mtmv
                             sql """ALTER MATERIALIZED VIEW ${mv_name1} rename 
${mv_name3};"""
+                            sleep(10 * 1000)
                             assertNoCache "select * from ${mv_name3}"
                             assertNoCache mtmv_sql1
                             assertHasCache "select * from ${nested_mv_name1}"
                             assertNoCache nested_mtmv_sql3
 
                             sql """ALTER MATERIALIZED VIEW ${mv_name3} rename 
${mv_name1};"""
+                            sleep(10 * 1000)
                             assertHasCache "select * from ${mv_name1}"  // 
Since this SQL query hasn't been executed before, so it's still valid now.
                             assertNoCache mtmv_sql1
                             assertHasCache "select * from ${nested_mv_name1}" 
// nested mtmv don't change
@@ -285,6 +288,8 @@ suite("mtmv_with_sql_cache") {
                             cur_create_async_partition_mv(dbName, mv_name4, 
mtmv_sql4, "(id)")
                             cur_create_async_partition_mv(dbName, 
nested_mv_name1, nested_mtmv_sql1, "(id)")
 
+                            sleep(10 * 1000)
+
                             sql "set enable_nereids_planner=true"
                             sql "set enable_fallback_to_original_planner=false"
                             sql "set enable_sql_cache=true"
@@ -320,6 +325,7 @@ suite("mtmv_with_sql_cache") {
 
                             // replace mtmv
                             sql """ALTER MATERIALIZED VIEW ${mv_name1} REPLACE 
WITH MATERIALIZED VIEW ${mv_name2};"""
+                            sleep(10 * 1000)
                             assertNoCache "select * from ${mv_name1}"
                             assertNoCache "select * from ${mv_name2}"
                             assertNoCache mtmv_sql1
@@ -328,6 +334,7 @@ suite("mtmv_with_sql_cache") {
                             assertNoCache nested_mtmv_sql1
 
                             sql """ALTER MATERIALIZED VIEW ${mv_name2} REPLACE 
WITH MATERIALIZED VIEW ${mv_name1};"""
+                            sleep(10 * 1000)
                             assertNoCache "select * from ${mv_name1}"
                             assertNoCache "select * from ${mv_name2}"
                             assertNoCache mtmv_sql1
@@ -399,6 +406,8 @@ suite("mtmv_with_sql_cache") {
                             cur_create_async_partition_mv(dbName, mv_name4, 
mtmv_sql4, "(id)")
                             cur_create_async_partition_mv(dbName, 
nested_mv_name1, nested_mtmv_sql1, "(id)")
 
+                            sleep(10 * 1000)
+
                             sql "set enable_nereids_planner=true"
                             sql "set enable_fallback_to_original_planner=false"
                             sql "set enable_sql_cache=true"
@@ -501,6 +510,8 @@ suite("mtmv_with_sql_cache") {
                             cur_create_async_partition_mv(dbName, mv_name4, 
mtmv_sql4, "(id)")
                             cur_create_async_partition_mv(dbName, 
nested_mv_name1, nested_mtmv_sql1, "(id)")
 
+                            sleep(10 * 1000)
+
                             sql "set enable_nereids_planner=true"
                             sql "set enable_fallback_to_original_planner=false"
                             sql "set enable_sql_cache=true"
@@ -538,6 +549,8 @@ suite("mtmv_with_sql_cache") {
                             sql "REFRESH MATERIALIZED VIEW ${mv_name1} AUTO;"
                             waitingMTMVTaskFinishedByMvName(mv_name1)
 
+                            sleep(10 * 1000)
+
                             assertHasCache "select * from ${mv_name1}"
                             assertHasCache mtmv_sql1
                             assertHasCache "select * from ${nested_mv_name1}"
@@ -568,7 +581,7 @@ suite("mtmv_with_sql_cache") {
                                     on t1.id = t2.id
                                 """
                             def mtmv_sql4 = """
-                                    select t1.id as id, t1.value as value1 
+                                    select t1.id as id, t1.value as value1
                                     from ${tb_name1} as t1
                                     left join ${tb_name2} as t2
                                     on t1.id = t2.id
@@ -593,6 +606,8 @@ suite("mtmv_with_sql_cache") {
                             cur_create_async_partition_mv(dbName, mv_name4, 
mtmv_sql4, "(id)")
                             cur_create_async_partition_mv(dbName, 
nested_mv_name1, nested_mtmv_sql1, "(id)")
 
+                            sleep(10 * 1000)
+
                             sql "set enable_nereids_planner=true"
                             sql "set enable_fallback_to_original_planner=false"
                             sql "set enable_sql_cache=true"
@@ -629,6 +644,8 @@ suite("mtmv_with_sql_cache") {
                             // refresh mtmv complete
                             sql "REFRESH MATERIALIZED VIEW ${mv_name1} 
complete;"
                             waitingMTMVTaskFinishedByMvName(mv_name1)
+                            sleep(10 * 1000)
+
                             assertNoCache "select * from ${mv_name1}"
                             assertNoCache mtmv_sql1
                             assertHasCache "select * from ${nested_mv_name1}"
@@ -692,6 +709,8 @@ suite("mtmv_with_sql_cache") {
                             cur_create_async_partition_mv(dbName, mv_name4, 
mtmv_sql4, "(id)")
                             cur_create_async_partition_mv(dbName, 
nested_mv_name1, nested_mtmv_sql1, "(id)")
 
+                            sleep(10 * 1000)
+
                             sql "set enable_nereids_planner=true"
                             sql "set enable_fallback_to_original_planner=false"
                             sql "set enable_sql_cache=true"
@@ -727,6 +746,7 @@ suite("mtmv_with_sql_cache") {
 
                             // base table insert overwrite
                             sql "INSERT OVERWRITE table ${tb_name1} 
PARTITION(p5) VALUES (5, 6);"
+                            sleep(10 * 1000)
                             assertHasCache "select * from ${mv_name1}"
                             assertNoCache mtmv_sql1
                             assertHasCache "select * from ${nested_mv_name1}"
@@ -737,6 +757,7 @@ suite("mtmv_with_sql_cache") {
 
                             sql "REFRESH MATERIALIZED VIEW ${mv_name1} AUTO;"
                             waitingMTMVTaskFinishedByMvName(mv_name1)
+                            sleep(10 * 1000)
                             assertNoCache "select * from ${mv_name1}"
                             assertNoCache mtmv_sql1
                             assertHasCache "select * from ${nested_mv_name1}"
@@ -799,6 +820,8 @@ suite("mtmv_with_sql_cache") {
                             cur_create_async_partition_mv(dbName, mv_name4, 
mtmv_sql4, "(id)")
                             cur_create_async_partition_mv(dbName, 
nested_mv_name1, nested_mtmv_sql1, "(id)")
 
+                            sleep(10 * 1000)
+
                             sql "set enable_nereids_planner=true"
                             sql "set enable_fallback_to_original_planner=false"
                             sql "set enable_sql_cache=true"
@@ -834,6 +857,7 @@ suite("mtmv_with_sql_cache") {
 
                             // add partition
                             sql "alter table ${tb_name1} add partition p6 
values[('6'),('7'))"
+                            sleep(10 * 1000)
                             assertHasCache "select * from ${mv_name1}"
                             assertNoCache mtmv_sql1
                             assertHasCache "select * from ${nested_mv_name1}"
@@ -844,6 +868,7 @@ suite("mtmv_with_sql_cache") {
 
                             // base table insert data
                             sql "insert into ${tb_name1} values(6, 1)"
+                            sleep(10 * 1000)
                             assertHasCache "select * from ${mv_name1}"
                             assertNoCache mtmv_sql1  // mtmv no work -> 
directly base table -> no cache
                             assertHasCache "select * from ${nested_mv_name1}"
@@ -907,6 +932,8 @@ suite("mtmv_with_sql_cache") {
                             cur_create_async_partition_mv(dbName, mv_name4, 
mtmv_sql4, "(id)")
                             cur_create_async_partition_mv(dbName, 
nested_mv_name1, nested_mtmv_sql1, "(id)")
 
+                            sleep(10 * 1000)
+
                             sql "set enable_nereids_planner=true"
                             sql "set enable_fallback_to_original_planner=false"
                             sql "set enable_sql_cache=true"
@@ -942,6 +969,7 @@ suite("mtmv_with_sql_cache") {
 
                             // recreate mtmv to add column
                             cur_create_async_partition_mv(dbName, mv_name1, 
mtmv_sql3, "(id)")
+                            sleep(10 * 1000)
                             assertNoCache "select * from ${mv_name1}"
                             assertHasCache "select * from ${mv_name2}"
                             assertNoCache mtmv_sql1
@@ -953,6 +981,7 @@ suite("mtmv_with_sql_cache") {
 
                             sql "REFRESH MATERIALIZED VIEW ${mv_name2} AUTO;"
                             waitingMTMVTaskFinishedByMvName(mv_name2)
+                            sleep(10 * 1000)
                             assertHasCache "select * from ${mv_name2}"
 
                             retryUntilHasSqlCache mtmv_sql1
diff --git a/regression-test/suites/nereids_p0/cache/mv_with_sql_cache.groovy 
b/regression-test/suites/nereids_p0/cache/mv_with_sql_cache.groovy
index 8c8a3a85c8f..1d13de06bc2 100644
--- a/regression-test/suites/nereids_p0/cache/mv_with_sql_cache.groovy
+++ b/regression-test/suites/nereids_p0/cache/mv_with_sql_cache.groovy
@@ -88,6 +88,7 @@ suite("mv_with_sql_cache") {
                             def prefix_str = "rename_mv_with_sql_cache_"
                             def tb_name1 = prefix_str + "table1"
                             createTestTable tb_name1
+                            sleep(10 * 1000)
 
                             def mv_name1 = prefix_str + "mv1"
                             def new_mv_name1 = prefix_str + "new_mv1"
@@ -114,6 +115,7 @@ suite("mv_with_sql_cache") {
                             // create mv
                             create_sync_mv(dbName, tb_name1, mv_name1, mv_sql1)
                             create_sync_mv(dbName, tb_name1, mv_name2, mv_sql2)
+                            sleep(10 * 1000)
 
                             assertHasCache "select * from ${tb_name1}"
                             assertHasCache mv_sql1
@@ -125,6 +127,7 @@ suite("mv_with_sql_cache") {
 
                             // alter rename
                             sql """ALTER TABLE ${tb_name1} RENAME ROLLUP 
${mv_name1} ${new_mv_name1};"""
+                            sleep(10 * 1000)
 
                             assertNoCache "select * from ${tb_name1}"
                             assertNoCache mv_sql1
@@ -148,6 +151,7 @@ suite("mv_with_sql_cache") {
                             def prefix_str = 
"create_mv_with_insert_data_sql_cache_"
                             def tb_name1 = prefix_str + "table1"
                             createTestTable tb_name1
+                            sleep(10 * 1000)
 
                             def mv_name1 = prefix_str + "mv1"
                             def new_mv_name1 = prefix_str + "new_mv1"
@@ -174,6 +178,7 @@ suite("mv_with_sql_cache") {
                             // create mv
                             create_sync_mv(dbName, tb_name1, mv_name1, mv_sql1)
                             create_sync_mv(dbName, tb_name1, mv_name2, mv_sql2)
+                            sleep(10 * 1000)
 
                             assertHasCache "select * from ${tb_name1}"
                             assertHasCache mv_sql1
@@ -185,6 +190,7 @@ suite("mv_with_sql_cache") {
 
                             // insert data
                             sql """insert into ${tb_name1} values (1, 3);"""
+                            sleep(10 * 1000)
                             assertNoCache "select * from ${tb_name1}"
                             sql "select * from ${tb_name1}"
                             assertHasCache "select * from ${tb_name1}"
@@ -208,6 +214,7 @@ suite("mv_with_sql_cache") {
                             def prefix_str = "drop_mv_with_sql_cache_"
                             def tb_name1 = prefix_str + "table1"
                             createTestTable tb_name1
+                            sleep(10 * 1000)
 
                             def mv_name1 = prefix_str + "mv1"
                             def new_mv_name1 = prefix_str + "new_mv1"
@@ -234,6 +241,7 @@ suite("mv_with_sql_cache") {
                             // create mv
                             create_sync_mv(dbName, tb_name1, mv_name1, mv_sql1)
                             create_sync_mv(dbName, tb_name1, mv_name2, mv_sql2)
+                            sleep(10 * 1000)
 
                             assertHasCache "select * from ${tb_name1}"
                             assertHasCache mv_sql1
@@ -245,6 +253,7 @@ suite("mv_with_sql_cache") {
 
                             // drop mv
                             sql """drop materialized view ${mv_name1} on 
${tb_name1};"""
+                            sleep(10 * 1000)
 
                             assertHasCache "select * from ${tb_name1}"
                             assertHasCache mv_sql1


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to