From adc44d9f463cd4cf6edbc7b64f65273ef9f6a88d Mon Sep 17 00:00:00 2001 From: zhangy5 Date: Fri, 28 Jul 2023 10:12:35 +0800 Subject: [PATCH] [regression-test] add list partition case and multi partition keys case (#22042) * [regression-test] add list partition case and multi partition keys case * fix delete failed --- .../list_partition/expect_baseall.out | 15 + .../list_partition/test_list_partition.out | 49 ++ .../test_list_partition_datatype.out | 20 + .../test_multi_column_partition.out | 184 ++++++ .../plugins/plugin_async_job_wait.groovy | 86 +++ .../list_partition/test_list_partition.groovy | 11 +- .../test_list_partition_datatype.groovy | 523 ++++++++++++++++++ .../test_multi_column_partition.groovy | 463 ++++++++++++++++ 8 files changed, 1348 insertions(+), 3 deletions(-) create mode 100644 regression-test/data/partition_p0/list_partition/expect_baseall.out create mode 100644 regression-test/data/partition_p0/list_partition/test_list_partition_datatype.out create mode 100644 regression-test/data/partition_p0/multi_partition/test_multi_column_partition.out create mode 100644 regression-test/plugins/plugin_async_job_wait.groovy create mode 100644 regression-test/suites/partition_p0/list_partition/test_list_partition_datatype.groovy create mode 100644 regression-test/suites/partition_p0/multi_partition/test_multi_column_partition.groovy diff --git a/regression-test/data/partition_p0/list_partition/expect_baseall.out b/regression-test/data/partition_p0/list_partition/expect_baseall.out new file mode 100644 index 0000000000..7abfbea6bd --- /dev/null +++ b/regression-test/data/partition_p0/list_partition/expect_baseall.out @@ -0,0 +1,15 @@ +false 1 1989 1001 11011902 170141183460469231731687303715884105727 123.123 true 1989-03-21 1989-03-21T13:00 wangjuoo4 0.1 6.333 string12345 +false 2 1986 1001 11011903 -170141183460469231731687303715884105727 1243.500 false 1901-12-31 1989-03-21T13:00 wangynnsf 20.268 789.25 string12345 +false 3 1989 1002 11011905 0 24453.325 false 2012-03-14 2000-01-01T00:00 yunlj8@nk 78945.0 3654.0 string12345 +false 4 1991 3021 -11011907 20220101 243243.325 false 3124-10-10 2015-03-13T10:30 yanvjldjlll 2.06 -0.001 string12345 +false 5 1985 5014 -11011903 20220102 243.325 true 2015-01-01 2015-03-13T12:36:38 du3lnvl -0.0 -365.0 string12345 +false 6 32767 3021 123456 20220104 604587.000 true 2014-11-11 2015-03-13T12:36:38 yanavnd 0.1 80699.0 string12345 +false 7 -32767 1002 7210457 -20220101 3.141 false 1988-03-21 1901-01-01T00:00 jiw3n4 0.0 6058.0 string12345 +true 8 255 2147483647 11011920 -2022 -0.123 true 1989-03-21 9999-11-11T12:12 wangjuoo5 987456.123 12.14 string12345 +true 9 1991 -2147483647 11011902 11011903 -654.654 true 1991-08-11 1989-03-21T13:11 wangjuoo4 0.0 69.123 string12345 +true 10 1991 5014 9223372036854775807 -11011903 -258.369 false 2015-04-02 2013-04-02T15:16:52 wangynnsf -123456.54 0.235 string12345 +true 11 1989 25699 -9223372036854775807 1701411834604692317316873037158 0.666 true 2015-04-02 1989-03-21T13:11 yunlj8@nk -987.001 4.336 string12345 +true 12 32767 -2147483647 9223372036854775807 1701604692317316873037158 243.325 false 1991-08-11 2013-04-02T15:16:52 lifsno -564.898 3.1415927 string12345 +true 13 -32767 2147483647 -9223372036854775807 701411834604692317316873037158 100.001 false 2015-04-02 2015-04-02T00:00 wenlsfnl 123.456 3.1415927 string12345 +true 14 255 103 11011902 701411834604692317316873 0.000 false 2015-04-02 2015-04-02T00:00 3.141592654 2.036 string12345 +true 15 1992 3021 11011920 701411834604692317 0.000 true 9999-12-12 2015-04-02T00:00 3.141592653 20.456 string12345 diff --git a/regression-test/data/partition_p0/list_partition/test_list_partition.out b/regression-test/data/partition_p0/list_partition/test_list_partition.out index e7797b07b2..77218d7056 100644 --- a/regression-test/data/partition_p0/list_partition/test_list_partition.out +++ b/regression-test/data/partition_p0/list_partition/test_list_partition.out @@ -12,3 +12,52 @@ 12 32767 -2147483647 13 -32767 2147483647 +-- !sql2 -- +6 32767 3021 123456 604587.000 true 2014-11-11 2015-03-13T12:36:38 yanavnd 0.1 80699.0 +7 -32767 1002 7210457 3.141 false 1988-03-21 1901-01-01T00:00 jiw3n4 0.0 6058.0 +8 255 2147483647 11011920 -0.123 true 1989-03-21 9999-11-11T12:12 wangjuoo5 987456.123 12.14 +9 1991 -2147483647 11011902 -654.654 true 1991-08-11 1989-03-21T13:11 wangjuoo4 0.0 69.123 +10 1991 5014 9223372036854775807 -258.369 false 2015-04-02 2013-04-02T15:16:52 wangynnsf -123456.54 0.235 +11 1989 25699 -9223372036854775807 0.666 true 2015-04-02 1989-03-21T13:11 yunlj8@nk -987.001 4.336 +12 32767 -2147483647 9223372036854775807 243.325 false 1991-08-11 2013-04-02T15:16:52 lifsno -564.898 3.1415927 +13 -32767 2147483647 -9223372036854775807 100.001 false 2015-04-02 2015-04-02T00:00 wenlsfnl 123.456 3.1415927 +14 255 103 11011902 0.000 false 2015-04-02 2015-04-02T00:00 3.141592654 2.036 +15 1992 3021 11011920 0.000 true 9999-12-12 2015-04-02T00:00 3.141592653 20.456 + +-- !sql3 -- +1 1989 1001 +5 1985 5014 +6 32767 3021 + +-- !sql4 -- +1 1989 1001 11011902 123.123 true 1989-03-21 1989-03-21T13:00 wangjuoo4 0.1 6.333 +2 1986 1001 11011903 1243.500 false 1901-12-31 1989-03-21T13:00 wangynnsf 20.268 789.25 +3 1989 1002 11011905 24453.325 false 2012-03-14 2000-01-01T00:00 yunlj8@nk 78945.0 3654.0 +4 1991 3021 -11011907 243243.325 false 3124-10-10 2015-03-13T10:30 yanvjldjlll 2.06 -0.001 +5 1985 5014 -11011903 243.325 true 2015-01-01 2015-03-13T12:36:38 du3lnvl -0.0 -365.0 +6 32767 3021 123456 604587.000 true 2014-11-11 2015-03-13T12:36:38 yanavnd 0.1 80699.0 +7 -32767 1002 7210457 3.141 false 1988-03-21 1901-01-01T00:00 jiw3n4 0.0 6058.0 +8 255 2147483647 11011920 -0.123 true 1989-03-21 9999-11-11T12:12 wangjuoo5 987456.123 12.14 +9 1991 -2147483647 11011902 -654.654 true 1991-08-11 1989-03-21T13:11 wangjuoo4 0.0 69.123 +11 1989 25699 -9223372036854775807 0.666 true 2015-04-02 1989-03-21T13:11 yunlj8@nk -987.001 4.336 +12 32767 -2147483647 9223372036854775807 243.325 false 1991-08-11 2013-04-02T15:16:52 lifsno -564.898 3.1415927 +13 -32767 2147483647 -9223372036854775807 100.001 false 2015-04-02 2015-04-02T00:00 wenlsfnl 123.456 3.1415927 +14 255 103 11011902 0.000 false 2015-04-02 2015-04-02T00:00 3.141592654 2.036 +15 1992 3021 11011920 0.000 true 9999-12-12 2015-04-02T00:00 3.141592653 20.456 + +-- !sql5 -- +4 1991 3021 +5 1985 5014 +6 32767 3021 +7 -32767 1002 +8 255 2147483647 +9 1991 -2147483647 +10 1991 5014 +11 1989 25699 +12 32767 -2147483647 +13 -32767 2147483647 +14 255 103 +15 1992 3021 + +-- !sql6 -- + diff --git a/regression-test/data/partition_p0/list_partition/test_list_partition_datatype.out b/regression-test/data/partition_p0/list_partition/test_list_partition_datatype.out new file mode 100644 index 0000000000..3323d6c290 --- /dev/null +++ b/regression-test/data/partition_p0/list_partition/test_list_partition_datatype.out @@ -0,0 +1,20 @@ +-- This file is automatically generated. You should know what you did if you want to edit this +-- !sql1 -- +0000-01-01 0000-01-01 +9999-12-31 9999-12-31 + +-- !sql2 -- +0000-01-01 0000-01-01 +2000-11-02 2000-11-03 +9999-12-31 9999-12-31 + +-- !sql3 -- +? a +a a +aaa b + +-- !sql4 -- + empty +aaaa 4a +ccc 3c + diff --git a/regression-test/data/partition_p0/multi_partition/test_multi_column_partition.out b/regression-test/data/partition_p0/multi_partition/test_multi_column_partition.out new file mode 100644 index 0000000000..fcb4c628fa --- /dev/null +++ b/regression-test/data/partition_p0/multi_partition/test_multi_column_partition.out @@ -0,0 +1,184 @@ +-- This file is automatically generated. You should know what you did if you want to edit this +-- !sql1 -- + +-- !sql2 -- + +-- !sql3 -- +1 10 100 1000 100000 2011-01-01T00:00 2010-01-01 t ynqnzeowymt 38.638844 180.998031 7395.2310670 + +-- !sql4 -- +2 20 200 2000 200000 2012-01-01T00:00 2010-01-02 f hfkfwlr 506.04404 539.922834 2080.5045020 + +-- !sql5 -- +3 30 300 3000 300000 2013-01-01T00:00 2010-01-03 t uoclasp 377.7932 577.044148 4605.2532050 + +-- !sql6 -- +4 40 400 4000 400000 2014-01-01T00:00 2010-01-04 n iswngzeodfhptjzgswsddt 871.35455 919.067864 7291.7037240 +5 50 500 5000 500000 2015-01-01T00:00 2010-01-05 a sqodagzlyrmcelyxgcgcsfuxadcdt 462.0679 929.660783 3903.9069010 +6 60 600 6000 600000 2016-01-01T00:00 2010-01-06 m obdrei 921.86786 882.708491 6514.4050510 +7 70 700 7000 700000 2017-01-01T00:00 2010-01-07 a cuobdhvrgkugknj 141.65642 209.420112 8604.1986770 +8 80 800 8000 800000 2018-01-01T00:00 2010-01-08 z phcxztwgjllhmj 762.81335 285.664871 7784.8594460 +9 90 900 9000 900000 2019-01-01T00:00 2010-01-09 b nbarqjwilbkelk 92.7024 535.28551 4846.7355930 +10 100 1000 10000 1000000 2020-01-01T00:00 2010-01-10 s zucprgdnlgzzfl 26.874739 155.861217 7996.4346860 +11 110 1100 11000 1100000 2021-01-01T00:00 2010-01-11 j zabbwiimqemk 369.81912 558.999245 3821.2787050 +12 120 1200 12000 1200000 2022-01-01T00:00 2010-01-12 d elvkhacywhdzrazcvyunkjajnx 536.04504 181.877653 9334.3009730 +13 130 1300 13000 1300000 2023-01-01T00:00 2010-01-13 x cylgmxlmkkrkk 990.83685 909.667873 9103.8044060 +14 140 1400 14000 1400000 2024-01-01T00:00 2010-01-14 s vpzwml 763.6152 295.541079 9823.0624960 +15 150 1500 15000 1500000 2025-01-01T00:00 2010-01-15 f yvvstxajxtgrimmrveljjbwo 380.41992 391.329557 5859.2419740 +16 160 1600 16000 1600000 2026-01-01T00:00 2010-01-16 b yxtowesbeqyejvpfhkixpdw 312.93396 328.666079 9430.1380130 +17 170 1700 17000 1700000 2027-01-01T00:00 2010-01-17 d nrrzcgygjplgttf 472.84436 799.528036 3135.2928420 +18 180 1800 18000 1800000 2028-01-01T00:00 2010-01-18 e wfknyaxplas 971.54944 844.025534 9855.8137110 +19 190 1900 19000 1900000 2029-01-01T00:00 2010-01-19 f qtznw 37.56896 502.584396 3086.5738740 +20 200 2000 20000 2000000 2030-01-01T00:00 2010-01-20 i nwznneizhtmzemy 632.5122 972.561324 2698.8636380 +21 210 2100 21000 2100000 2031-01-01T00:00 2010-01-21 q sqqeanrmafdoheeizljifwsj 942.88873 933.754744 5185.3730390 +22 220 2200 22000 2200000 2032-01-01T00:00 2010-01-22 h tirlgqmwrchusfyxitxttvxlioknz 654.95593 69.032071 6221.3482910 +23 230 2300 23000 2300000 2033-01-01T00:00 2010-01-23 s imnrusvqy 468.78033 24.626005 7481.5746570 +24 240 2400 24000 2400000 2034-01-01T00:00 2010-01-24 s irpbe 537.9061 396.750845 3585.2088090 +25 250 2500 25000 2500000 2035-01-01T00:00 2010-01-25 w drpjerrdlel 662.1232 202.007097 6982.7960600 +26 260 2600 26000 2600000 2036-01-01T00:00 2010-01-26 v vmzutsaifmlimicshgjpsvhiowjnq 115.1456 64.115478 3046.8392030 +27 270 2700 27000 2700000 2037-01-01T00:00 2010-01-27 d yrxspxgcwgbnjnmqkcido 362.2272 519.383701 9921.1350450 +28 280 2800 28000 2800000 2038-01-01T00:00 2010-01-28 w udfzebgnnxfjnoujtvlib 443.03085 998.4716 4633.2586980 +29 290 2900 29000 2900000 2039-01-01T00:00 2010-01-29 p jfgvke 8.602754 248.265099 5465.0103450 +30 300 3000 30000 3000000 2040-01-01T00:00 2010-01-30 d tbuvpobzluhbwkljlhwnrkrhowybk 949.5756 976.26649 2579.6686360 + +-- !sql7 -- +0 + +-- !sql8 -- + +-- !sql9 -- +0 100 0 0 0 0 2000-01-01T00:00 2000-01-01 a a 0.001 -0.001 0.0010000 +1 0 10 100 1000 100000 2011-01-01T00:00 2010-01-01 t ynqnzeowymt 38.638844 180.998031 7395.2310670 +2 0 20 200 2000 200000 2012-01-01T00:00 2010-01-02 f hfkfwlr 506.04404 539.922834 2080.5045020 +3 0 30 300 3000 300000 2013-01-01T00:00 2010-01-03 t uoclasp 377.7932 577.044148 4605.2532050 +4 0 40 400 4000 400000 2014-01-01T00:00 2010-01-04 n iswngzeodfhptjzgswsddt 871.35455 919.067864 7291.7037240 +5 0 50 500 5000 500000 2015-01-01T00:00 2010-01-05 a sqodagzlyrmcelyxgcgcsfuxadcdt 462.0679 929.660783 3903.9069010 +6 0 60 600 6000 600000 2016-01-01T00:00 2010-01-06 m obdrei 921.86786 882.708491 6514.4050510 +7 0 70 700 7000 700000 2017-01-01T00:00 2010-01-07 a cuobdhvrgkugknj 141.65642 209.420112 8604.1986770 +8 0 80 800 8000 800000 2018-01-01T00:00 2010-01-08 z phcxztwgjllhmj 762.81335 285.664871 7784.8594460 +9 0 90 900 9000 900000 2019-01-01T00:00 2010-01-09 b nbarqjwilbkelk 92.7024 535.28551 4846.7355930 +10 0 100 1000 10000 1000000 2020-01-01T00:00 2010-01-10 s zucprgdnlgzzfl 26.874739 155.861217 7996.4346860 +11 0 110 1100 11000 1100000 2021-01-01T00:00 2010-01-11 j zabbwiimqemk 369.81912 558.999245 3821.2787050 +12 0 120 1200 12000 1200000 2022-01-01T00:00 2010-01-12 d elvkhacywhdzrazcvyunkjajnx 536.04504 181.877653 9334.3009730 +13 0 130 1300 13000 1300000 2023-01-01T00:00 2010-01-13 x cylgmxlmkkrkk 990.83685 909.667873 9103.8044060 +14 0 140 1400 14000 1400000 2024-01-01T00:00 2010-01-14 s vpzwml 763.6152 295.541079 9823.0624960 +15 0 150 1500 15000 1500000 2025-01-01T00:00 2010-01-15 f yvvstxajxtgrimmrveljjbwo 380.41992 391.329557 5859.2419740 +16 0 160 1600 16000 1600000 2026-01-01T00:00 2010-01-16 b yxtowesbeqyejvpfhkixpdw 312.93396 328.666079 9430.1380130 +17 0 170 1700 17000 1700000 2027-01-01T00:00 2010-01-17 d nrrzcgygjplgttf 472.84436 799.528036 3135.2928420 +18 0 180 1800 18000 1800000 2028-01-01T00:00 2010-01-18 e wfknyaxplas 971.54944 844.025534 9855.8137110 +19 0 190 1900 19000 1900000 2029-01-01T00:00 2010-01-19 f qtznw 37.56896 502.584396 3086.5738740 +20 0 200 2000 20000 2000000 2030-01-01T00:00 2010-01-20 i nwznneizhtmzemy 632.5122 972.561324 2698.8636380 +21 0 210 2100 21000 2100000 2031-01-01T00:00 2010-01-21 q sqqeanrmafdoheeizljifwsj 942.88873 933.754744 5185.3730390 +22 0 220 2200 22000 2200000 2032-01-01T00:00 2010-01-22 h tirlgqmwrchusfyxitxttvxlioknz 654.95593 69.032071 6221.3482910 +23 0 230 2300 23000 2300000 2033-01-01T00:00 2010-01-23 s imnrusvqy 468.78033 24.626005 7481.5746570 +24 0 240 2400 24000 2400000 2034-01-01T00:00 2010-01-24 s irpbe 537.9061 396.750845 3585.2088090 +25 0 250 2500 25000 2500000 2035-01-01T00:00 2010-01-25 w drpjerrdlel 662.1232 202.007097 6982.7960600 +26 0 260 2600 26000 2600000 2036-01-01T00:00 2010-01-26 v vmzutsaifmlimicshgjpsvhiowjnq 115.1456 64.115478 3046.8392030 +27 0 270 2700 27000 2700000 2037-01-01T00:00 2010-01-27 d yrxspxgcwgbnjnmqkcido 362.2272 519.383701 9921.1350450 +28 0 280 2800 28000 2800000 2038-01-01T00:00 2010-01-28 w udfzebgnnxfjnoujtvlib 443.03085 998.4716 4633.2586980 +29 0 290 2900 29000 2900000 2039-01-01T00:00 2010-01-29 p jfgvke 8.602754 248.265099 5465.0103450 +30 0 300 3000 30000 3000000 2040-01-01T00:00 2010-01-30 d tbuvpobzluhbwkljlhwnrkrhowybk 949.5756 976.26649 2579.6686360 + +-- !sql10 -- +100 0 0 0 0 2000-01-01T00:00 0.001 -0.001 0.0010000 +1 10 100 1000 100000 2011-01-01T00:00 38.638844 180.998031 7395.2310670 +2 20 200 2000 200000 2012-01-01T00:00 506.04404 539.922834 2080.5045020 +3 30 300 3000 300000 2013-01-01T00:00 377.7932 577.044148 4605.2532050 +4 40 400 4000 400000 2014-01-01T00:00 871.35455 919.067864 7291.7037240 +5 50 500 5000 500000 2015-01-01T00:00 462.0679 929.660783 3903.9069010 +6 60 600 6000 600000 2016-01-01T00:00 921.86786 882.708491 6514.4050510 +7 70 700 7000 700000 2017-01-01T00:00 141.65642 209.420112 8604.1986770 +8 80 800 8000 800000 2018-01-01T00:00 762.81335 285.664871 7784.8594460 +9 90 900 9000 900000 2019-01-01T00:00 92.7024 535.28551 4846.7355930 +10 100 1000 10000 1000000 2020-01-01T00:00 26.874739 155.861217 7996.4346860 +11 110 1100 11000 1100000 2021-01-01T00:00 369.81912 558.999245 3821.2787050 +12 120 1200 12000 1200000 2022-01-01T00:00 536.04504 181.877653 9334.3009730 +13 130 1300 13000 1300000 2023-01-01T00:00 990.83685 909.667873 9103.8044060 +14 140 1400 14000 1400000 2024-01-01T00:00 763.6152 295.541079 9823.0624960 +15 150 1500 15000 1500000 2025-01-01T00:00 380.41992 391.329557 5859.2419740 +16 160 1600 16000 1600000 2026-01-01T00:00 312.93396 328.666079 9430.1380130 +17 170 1700 17000 1700000 2027-01-01T00:00 472.84436 799.528036 3135.2928420 +18 180 1800 18000 1800000 2028-01-01T00:00 971.54944 844.025534 9855.8137110 +19 190 1900 19000 1900000 2029-01-01T00:00 37.56896 502.584396 3086.5738740 +20 200 2000 20000 2000000 2030-01-01T00:00 632.5122 972.561324 2698.8636380 +21 210 2100 21000 2100000 2031-01-01T00:00 942.88873 933.754744 5185.3730390 +22 220 2200 22000 2200000 2032-01-01T00:00 654.95593 69.032071 6221.3482910 +23 230 2300 23000 2300000 2033-01-01T00:00 468.78033 24.626005 7481.5746570 +24 240 2400 24000 2400000 2034-01-01T00:00 537.9061 396.750845 3585.2088090 +25 250 2500 25000 2500000 2035-01-01T00:00 662.1232 202.007097 6982.7960600 +26 260 2600 26000 2600000 2036-01-01T00:00 115.1456 64.115478 3046.8392030 +27 270 2700 27000 2700000 2037-01-01T00:00 362.2272 519.383701 9921.1350450 +28 280 2800 28000 2800000 2038-01-01T00:00 443.03085 998.4716 4633.2586980 +29 290 2900 29000 2900000 2039-01-01T00:00 8.602754 248.265099 5465.0103450 +30 300 3000 30000 3000000 2040-01-01T00:00 949.5756 976.26649 2579.6686360 + +-- !sql11 -- +100 0 0 0 0 2000-01-01T00:00 0.001 -0.001 0.0010000 +1 10 100 1000 100000 2011-01-01T00:00 38.638844 180.998031 7395.2310670 +2 20 200 2000 200000 2012-01-01T00:00 506.04404 539.922834 2080.5045020 +3 30 300 3000 300000 2013-01-01T00:00 377.7932 577.044148 4605.2532050 +4 40 400 4000 400000 2014-01-01T00:00 871.35455 919.067864 7291.7037240 +5 50 500 5000 500000 2015-01-01T00:00 462.0679 929.660783 3903.9069010 +6 60 600 6000 600000 2016-01-01T00:00 921.86786 882.708491 6514.4050510 +7 70 700 7000 700000 2017-01-01T00:00 141.65642 209.420112 8604.1986770 +8 80 800 8000 800000 2018-01-01T00:00 762.81335 285.664871 7784.8594460 +9 90 900 9000 900000 2019-01-01T00:00 92.7024 535.28551 4846.7355930 +10 100 1000 10000 1000000 2020-01-01T00:00 26.874739 155.861217 7996.4346860 +11 110 1100 11000 1100000 2021-01-01T00:00 369.81912 558.999245 3821.2787050 +12 120 1200 12000 1200000 2022-01-01T00:00 536.04504 181.877653 9334.3009730 +13 130 1300 13000 1300000 2023-01-01T00:00 990.83685 909.667873 9103.8044060 +14 140 1400 14000 1400000 2024-01-01T00:00 763.6152 295.541079 9823.0624960 +15 150 1500 15000 1500000 2025-01-01T00:00 380.41992 391.329557 5859.2419740 +16 160 1600 16000 1600000 2026-01-01T00:00 312.93396 328.666079 9430.1380130 +17 170 1700 17000 1700000 2027-01-01T00:00 472.84436 799.528036 3135.2928420 +18 180 1800 18000 1800000 2028-01-01T00:00 971.54944 844.025534 9855.8137110 +19 190 1900 19000 1900000 2029-01-01T00:00 37.56896 502.584396 3086.5738740 +20 200 2000 20000 2000000 2030-01-01T00:00 632.5122 972.561324 2698.8636380 +21 210 2100 21000 2100000 2031-01-01T00:00 942.88873 933.754744 5185.3730390 +22 220 2200 22000 2200000 2032-01-01T00:00 654.95593 69.032071 6221.3482910 +23 230 2300 23000 2300000 2033-01-01T00:00 468.78033 24.626005 7481.5746570 +24 240 2400 24000 2400000 2034-01-01T00:00 537.9061 396.750845 3585.2088090 +25 250 2500 25000 2500000 2035-01-01T00:00 662.1232 202.007097 6982.7960600 +26 260 2600 26000 2600000 2036-01-01T00:00 115.1456 64.115478 3046.8392030 +27 270 2700 27000 2700000 2037-01-01T00:00 362.2272 519.383701 9921.1350450 +28 280 2800 28000 2800000 2038-01-01T00:00 443.03085 998.4716 4633.2586980 +29 290 2900 29000 2900000 2039-01-01T00:00 8.602754 248.265099 5465.0103450 +30 300 3000 30000 3000000 2040-01-01T00:00 949.5756 976.26649 2579.6686360 + +-- !sql12 -- +1 10 100 1000 100000 2011-01-01T00:00 2010-01-01 t ynqnzeowymt 38.638844 180.998031 7395.2310670 +2 20 200 2000 200000 2012-01-01T00:00 2010-01-02 f hfkfwlr 506.04404 539.922834 2080.5045020 +3 30 300 3000 300000 2013-01-01T00:00 2010-01-03 t uoclasp 377.7932 577.044148 4605.2532050 +4 40 400 4000 400000 2014-01-01T00:00 2010-01-04 n iswngzeodfhptjzgswsddt 871.35455 919.067864 7291.7037240 +5 50 500 5000 500000 2015-01-01T00:00 2010-01-05 a sqodagzlyrmcelyxgcgcsfuxadcdt 462.0679 929.660783 3903.9069010 +6 60 600 6000 600000 2016-01-01T00:00 2010-01-06 m obdrei 921.86786 882.708491 6514.4050510 +7 70 700 7000 700000 2017-01-01T00:00 2010-01-07 a cuobdhvrgkugknj 141.65642 209.420112 8604.1986770 +8 80 800 8000 800000 2018-01-01T00:00 2010-01-08 z phcxztwgjllhmj 762.81335 285.664871 7784.8594460 +9 90 900 9000 900000 2019-01-01T00:00 2010-01-09 b nbarqjwilbkelk 92.7024 535.28551 4846.7355930 +10 100 1000 10000 1000000 2020-01-01T00:00 2010-01-10 s zucprgdnlgzzfl 26.874739 155.861217 7996.4346860 +11 110 1100 11000 1100000 2021-01-01T00:00 2010-01-11 j zabbwiimqemk 369.81912 558.999245 3821.2787050 +12 120 1200 12000 1200000 2022-01-01T00:00 2010-01-12 d elvkhacywhdzrazcvyunkjajnx 536.04504 181.877653 9334.3009730 +13 130 1300 13000 1300000 2023-01-01T00:00 2010-01-13 x cylgmxlmkkrkk 990.83685 909.667873 9103.8044060 +14 140 1400 14000 1400000 2024-01-01T00:00 2010-01-14 s vpzwml 763.6152 295.541079 9823.0624960 +15 150 1500 15000 1500000 2025-01-01T00:00 2010-01-15 f yvvstxajxtgrimmrveljjbwo 380.41992 391.329557 5859.2419740 +16 160 1600 16000 1600000 2026-01-01T00:00 2010-01-16 b yxtowesbeqyejvpfhkixpdw 312.93396 328.666079 9430.1380130 +17 170 1700 17000 1700000 2027-01-01T00:00 2010-01-17 d nrrzcgygjplgttf 472.84436 799.528036 3135.2928420 +18 180 1800 18000 1800000 2028-01-01T00:00 2010-01-18 e wfknyaxplas 971.54944 844.025534 9855.8137110 +19 190 1900 19000 1900000 2029-01-01T00:00 2010-01-19 f qtznw 37.56896 502.584396 3086.5738740 +20 200 2000 20000 2000000 2030-01-01T00:00 2010-01-20 i nwznneizhtmzemy 632.5122 972.561324 2698.8636380 +21 210 2100 21000 2100000 2031-01-01T00:00 2010-01-21 q sqqeanrmafdoheeizljifwsj 942.88873 933.754744 5185.3730390 +22 220 2200 22000 2200000 2032-01-01T00:00 2010-01-22 h tirlgqmwrchusfyxitxttvxlioknz 654.95593 69.032071 6221.3482910 +23 230 2300 23000 2300000 2033-01-01T00:00 2010-01-23 s imnrusvqy 468.78033 24.626005 7481.5746570 +24 240 2400 24000 2400000 2034-01-01T00:00 2010-01-24 s irpbe 537.9061 396.750845 3585.2088090 +25 250 2500 25000 2500000 2035-01-01T00:00 2010-01-25 w drpjerrdlel 662.1232 202.007097 6982.7960600 +26 260 2600 26000 2600000 2036-01-01T00:00 2010-01-26 v vmzutsaifmlimicshgjpsvhiowjnq 115.1456 64.115478 3046.8392030 +27 270 2700 27000 2700000 2037-01-01T00:00 2010-01-27 d yrxspxgcwgbnjnmqkcido 362.2272 519.383701 9921.1350450 +28 280 2800 28000 2800000 2038-01-01T00:00 2010-01-28 w udfzebgnnxfjnoujtvlib 443.03085 998.4716 4633.2586980 +29 290 2900 29000 2900000 2039-01-01T00:00 2010-01-29 p jfgvke 8.602754 248.265099 5465.0103450 +30 300 3000 30000 3000000 2040-01-01T00:00 2010-01-30 d tbuvpobzluhbwkljlhwnrkrhowybk 949.5756 976.26649 2579.6686360 + +-- !sql13 -- +10 -100 +10 100 +30 -32768 + diff --git a/regression-test/plugins/plugin_async_job_wait.groovy b/regression-test/plugins/plugin_async_job_wait.groovy new file mode 100644 index 0000000000..fa78482ebb --- /dev/null +++ b/regression-test/plugins/plugin_async_job_wait.groovy @@ -0,0 +1,86 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +import org.apache.doris.regression.suite.Suite + +// Usage: getLoadFinalState("label") +// Usage: assertEquals("FINISHED"， getLoadFinalState("label1")) +Suite.metaClass.getLoadFinalState = { String label /* param */ -> + Suite suite = delegate as Suite + String showLoadSql = "SHOW LOAD WHERE Label='${label}' ORDER BY CreateTime DESC LIMIT 1" + int max_try_time = 300 + String jobState = "" + // wait job finished/cancelled + while(max_try_time--){ + def loadJob = sql showLoadSql + jobState = loadJob[0][2] + if (jobState == "FINISHED" || jobState == "CANCELLED") { + sleep(3000) + logger.info("load job: label=${label} is ${jobState}, msg: ${loadJob[0][7]}") + return jobState + } else { + sleep(1000) + } + } + logger.info("load job: label=${label} wait for 300s, status is ${jobState}... return") + return jobState +} +logger.info("Added 'getLoadFinalState' function to Suite") + + +Suite.metaClass.getAlterColumnFinalState = { String tableName /* param */ -> + Suite suite = delegate as Suite + String showAlterColumnSql = "SHOW ALTER TABLE COLUMN WHERE TableName = '${tableName}' ORDER BY CreateTime DESC LIMIT 1" + int max_try_time = 300 + String jobState = "" + while(max_try_time--){ + def alterJob = sql showAlterColumnSql + jobState = alterJob[0][9] + if (jobState == "FINISHED" || jobState == "CANCELLED") { + sleep(3000) + logger.info("alter table ${tableName} column job is ${jobState}, msg: ${alterJob[0][10]} ") + return jobState + } else { + sleep(1000) + } + } + logger.info("alter table ${tableName} column job wait for 300s, status is ${jobState} ... return") + return jobState +} +logger.info("Added 'getAlterColumnFinalState' function to Suite") + + +Suite.metaClass.getAlterRollupFinalState = { String tableName /* param */ -> + Suite suite = delegate as Suite + String showAlterRollupSql = "SHOW ALTER TABLE ROLLUP WHERE TableName = '${tableName}' ORDER BY CreateTime DESC LIMIT 1" + int max_try_time = 300 + String jobState = "" + while(max_try_time--){ + def alterJob = sql showAlterRollupSql + jobState = alterJob[0][8] + if (jobState == "FINISHED" || jobState == "CANCELLED") { + sleep(3000) + logger.info("alter table ${tableName} rollup job is ${jobState}, msg: ${alterJob[0][9]} ") + return jobState + } else { + sleep(1000) + } + } + logger.info("alter table ${tableName} rollup job wait for 300s, status is ${jobState}... return") + return jobState +} +logger.info("Added 'getAlterRollupFinalState' function to Suite") diff --git a/regression-test/suites/partition_p0/list_partition/test_list_partition.groovy b/regression-test/suites/partition_p0/list_partition/test_list_partition.groovy index 78dee0676f..a12879393e 100644 --- a/regression-test/suites/partition_p0/list_partition/test_list_partition.groovy +++ b/regression-test/suites/partition_p0/list_partition/test_list_partition.groovy @@ -15,8 +15,8 @@ // specific language governing permissions and limitations // under the License. -suite("test_list_partition") { - // todo: test list partitions, such as: create, alter table partition ... +suite("test_list_partition", "p0") { + // test query list partition table sql "drop table if exists list_par" sql """ CREATE TABLE IF NOT EXISTS list_par ( @@ -77,5 +77,10 @@ suite("test_list_partition") { sql "insert into test_list_partition_select_tb select k1, k2, k3, k4, k5, k6, k10, k11, k7, k8, k9 from test_query_db.baseall where k1 is not null;" - qt_sql1 "select k1, k2, k3 from test_list_partition_select_tb where k1 between 3 and 13 order by 1, 2, 3;" + qt_sql1 "select k1, k2, k3 from test_list_partition_select_tb where k1 between 3 and 13 order by 1, 2, 3" + qt_sql2 "select * from test_list_partition_select_tb where k1 > 5 order by k1" + qt_sql3 "select k1, k2, k3 from test_list_partition_select_tb where k1 in (5, 6, 1) order by k1" + qt_sql4 "select * from test_list_partition_select_tb where k1 != 10 order by k1" + qt_sql5 "select k1, k2, k3 from test_list_partition_select_tb where k1 not in (1, 2, 3, 100) order by k1" + qt_sql6 "select * from test_list_partition_select_tb where k1 is null order by k1;" } diff --git a/regression-test/suites/partition_p0/list_partition/test_list_partition_datatype.groovy b/regression-test/suites/partition_p0/list_partition/test_list_partition_datatype.groovy new file mode 100644 index 0000000000..b532d9de20 --- /dev/null +++ b/regression-test/suites/partition_p0/list_partition/test_list_partition_datatype.groovy @@ -0,0 +1,523 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +suite("test_list_partition_datatype", "p0") { + def aggCol = """ + k0 boolean NOT NULL, + k1 tinyint NOT NULL, + k2 smallint NOT NULL, + k3 int NOT NULL, + k4 bigint NOT NULL, + k13 largeint NOT NULL, + k5 decimal(9, 3) NOT NULL, + k6 char(5) NOT NULL, + k10 date NOT NULL, + k11 datetime NOT NULL, + k7 varchar(20) NOT NULL, + k8 double max NOT NULL, + k9 float sum NOT NULL, + k12 string replace NOT NULL + """ + def nonAggCol = """ + k0 boolean NOT NULL, + k1 tinyint NOT NULL, + k2 smallint NOT NULL, + k3 int NOT NULL, + k4 bigint NOT NULL, + k13 largeint NOT NULL, + k5 decimal(9, 3) NOT NULL, + k6 char(5) NOT NULL, + k10 date NOT NULL, + k11 datetime NOT NULL, + k7 varchar(20) NOT NULL, + k8 double NOT NULL, + k9 float NOT NULL, + k12 string NOT NULL + """ + def dupKey = "DUPLICATE KEY(k0,k1,k2,k3,k4,k13,k5,k6,k10,k11,k7) " + def uniqKey = "UNIQUE KEY(k0,k1,k2,k3,k4,k13,k5,k6,k10,k11,k7) " + sql "set enable_insert_strict=true" + def initTableAndCheck = { String tableName, String column, String keyDesc, String partitionInfo /* param */ -> + sql """DROP TABLE IF EXISTS ${tableName}""" + sql """ + CREATE TABLE IF NOT EXISTS ${tableName} (${column}) ${keyDesc} ${partitionInfo} + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + streamLoad { + table tableName + set "column_separator", "," + set "columns", "k0, k1, k2, k3, k4, k5, k6, k10, k11, k7, k8, k9, k12, k13" + set "max_filter_ratio", "0.1" + file "../../query_p0/baseall.txt" + check { result, exception, startTime, endTime -> + if (exception != null) { + throw exception + } + log.info("Stream load result: ${result}".toString()) + def json = parseJson(result) + assertEquals("success", json.Status.toLowerCase()) + assertEquals(15, json.NumberLoadedRows) + } + } + test { + sql "SELECT * FROM ${tableName} ORDER BY k1, k2" + resultFile "expect_baseall.out" + } + def result = sql "SHOW PARTITIONS FROM ${tableName}" + assertTrue(result.size() > 1) + try_sql """DROP TABLE ${tableName}""" + } + def tblTypesCheck = { String tableName, String partitionInfo /* param */ -> + initTableAndCheck("${tableName}_agg", aggCol, '', partitionInfo) + initTableAndCheck("${tableName}_dup", nonAggCol, dupKey, partitionInfo) + initTableAndCheck("${tableName}_uniq", nonAggCol, uniqKey, partitionInfo) + } + // aggregate/duplicate/unique table with tinyint list partition key, check create, load and select + tblTypesCheck("test_list_partition_tinyint", + """ + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1","2","3","4"), + PARTITION p2 VALUES IN ("5","6","7","8","9","10","11","12","13","14"), + PARTITION p3 VALUES IN ("15") ) + """) + // aggregate/duplicate/unique table with smallint list partition key, check create, load and select + tblTypesCheck("test_list_partition_smallint", + """ + PARTITION BY LIST(k2) ( + PARTITION p1 VALUES IN ("-32767","32767"), + PARTITION p2 VALUES IN ("255"), PARTITION + p3 VALUES IN ("1985","1986","1989","1991","1992") ) + """) + // aggregate/duplicate/unique table with int list partition key, check create, load and select + tblTypesCheck("test_list_partition_int", + """ + PARTITION BY LIST(k3) ( + PARTITION p1 VALUES IN ("-2147483647","2147483647"), + PARTITION p2 VALUES IN ("1001","3021"), + PARTITION p3 VALUES IN ("1002","25699","103","5014","1992") ) + """) + // aggregate/duplicate/unique table with bigint list partition key, check create, load and select + tblTypesCheck("test_list_partition_bigint", + """ + PARTITION BY LIST(k4) ( + PARTITION p1 VALUES IN ("11011905","11011903"), + PARTITION p2 VALUES IN ("-11011903","11011920","-11011907"), + PARTITION p3 VALUES IN ("9223372036854775807","-9223372036854775807","11011902","7210457","123456") ) + """) + // aggregate/duplicate/unique table with largeint list partition key, check create, load and select + tblTypesCheck("test_list_partition_largeint", + """ + PARTITION BY LIST(k13) ( + PARTITION p1 VALUES IN ("-170141183460469231731687303715884105727", "-20220101", "-11011903", "-2022"), + PARTITION p2 VALUES IN ("0", "11011903", "20220101", "20220102", "20220104", "701411834604692317"), + PARTITION p3 VALUES IN ("701411834604692317316873", "1701604692317316873037158", "701411834604692317316873037158"), + PARTITION p4 VALUES IN ("1701411834604692317316873037158", "170141183460469231731687303715884105727")) + """) + // aggregate/duplicate/unique table with date list partition key, check create, load and select + tblTypesCheck("test_list_partition_date", + """ + PARTITION BY LIST(k10) ( + PARTITION p1 VALUES IN ("1901-12-31","1988-03-21"), + PARTITION p2 VALUES IN ("1989-03-21","1991-08-11","2012-03-14"), + PARTITION p3 VALUES IN ("2014-11-11","2015-01-01","2015-04-02","3124-10-10","9999-12-12") ) + """) + // aggregate/duplicate/unique table with datetime list partition key, check create, load and select + tblTypesCheck("test_list_partition_datetime", + """ + PARTITION BY LIST(k11) ( + PARTITION p1 VALUES IN ("1901-01-01 00:00:00","1989-03-21 13:00:00","1989-03-21 13:11:00"), + PARTITION p2 VALUES IN ("2000-01-01 00:00:00","2013-04-02 15:16:52","2015-03-13 10:30:00"), + PARTITION p3 VALUES IN ("2015-03-13 12:36:38","2015-04-02 00:00:00","9999-11-11 12:12:00") ) + """) + // aggregate/duplicate/unique table with char list partition key, check create, load and select + tblTypesCheck("test_list_partition_char", + """ + PARTITION BY LIST(k6) ( + PARTITION p1 VALUES IN ("true"), + PARTITION p2 VALUES IN ("false"), + PARTITION p3 VALUES IN ("") ) + """) + // aggregate/duplicate/unique table with varchar list partition key, check create, load and select + tblTypesCheck("test_list_partition_varchar", + """ + PARTITION BY LIST(k7) ( + PARTITION p1 VALUES IN (""," "), + PARTITION p2 VALUES IN ("du3lnvl","jiw3n4","lifsno","wangjuoo4","wangjuoo5"), + PARTITION p3 VALUES IN ("wangynnsf","wenlsfnl","yanavnd","yanvjldjlll","yunlj8@nk") ) + """) + // aggregate/duplicate/unique table with boolean list partition key, check create, load and select + tblTypesCheck("test_list_partition_boolean", + """ + PARTITION BY LIST(k0) ( + PARTITION p1 VALUES IN ("true"), + PARTITION p2 VALUES IN ("false")) + """) + // not support decimal as list partition key + test { + sql "CREATE TABLE test_list_partition_err_tbl_1 ( k1 tinyint NOT NULL, k5 decimal(9, 3) NOT NULL, " + + "k8 double max NOT NULL, k9 float sum NOT NULL ) " + + "PARTITION BY LIST(k5) ( " + + " PARTITION p1 VALUES IN (\"-654.654\")," + + " PARTITION p2 VALUES IN (\"0\"), " + + " PARTITION p3 VALUES IN (\"243243.325\") ) " + + "DISTRIBUTED BY HASH(k1) BUCKETS 5" + exception "Column[k5] type[DECIMAL32] cannot be a list partition key" + } + // aggregate/duplicate/unique table with multi column list partition keys, check create, load and select + tblTypesCheck( + "test_list_partition_basic_tbl", + """ + PARTITION BY LIST(k2,k10,k7) ( + PARTITION p1 VALUES IN (("-32767","1988-03-21","jiw3n4"),("-32767","2015-04-02","wenlsfnl"), + ("255","1989-03-21","wangjuoo5"),("255","2015-04-02"," "),("1985","2015-01-01","du3lnvl")), + PARTITION p2 VALUES IN (("1986","1901-12-31","wangynnsf"),("1989","1989-03-21","wangjuoo4"), + ("1989","2012-03-14","yunlj8@nk"),("1989","2015-04-02","yunlj8@nk"),("1991","1991-08-11","wangjuoo4")), + PARTITION p3 VALUES IN (("1991","2015-04-02","wangynnsf"),("1991","3124-10-10","yanvjldjlll"), + ("1992","9999-12-12",""),("32767","1991-08-11","lifsno"),("32767","2014-11-11","yanavnd")) ) + """ + ) + // int list partition errors like: duplicate key, conflict, invalid format + test { + sql """CREATE TABLE test_list_partition_err_tbl_1 ( + k1 INT NOT NULL, + v1 INT SUM NOT NULL, + v2 INT MAX NOT NULL, + v3 INT MIN NOT NULL, + v4 INT REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1","2","3"), + PARTITION p2 VALUES IN ("10","10"), + PARTITION p3 VALUES IN ("100"), + PARTITION p4 VALUES IN ("-100","0") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1")""" + exception "The partition key[('10','10')] has duplicate item [(\"10\")]." + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_2 ( + k1 INT NOT NULL, + v1 INT SUM NOT NULL, + v2 INT MAX NOT NULL, + v3 INT MIN NOT NULL, + v4 INT REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1","2","3"), + PARTITION p2 VALUES IN ("10"), + PARTITION p3 VALUES IN ("100","-0"), + PARTITION p4 VALUES IN ("-100","0") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception """ Invalid list value format: errCode = 2, detailMessage = The partition key[("0")] in partition item[('-100','0')] is conflict with current partitionKeys[(("100"),("0"))]""" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_3 ( + k1 INT NOT NULL, + v1 INT SUM NOT NULL, + v2 INT MAX NOT NULL, + v3 INT MIN NOT NULL, + v4 INT REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1","2","3"), + PARTITION p2 VALUES IN ("10"), + PARTITION p3 VALUES IN ("100","-10","NULL"), + PARTITION p4 VALUES IN ("-100","0") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1")""" + exception "Invalid list value format: errCode = 2, detailMessage = Invalid number format: NULL" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_4 ( + k1 INT NOT NULL, + v1 INT SUM NOT NULL, + v2 INT MAX NOT NULL, + v3 INT MIN NOT NULL, + v4 INT REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1","2","3"), + PARTITION p2 VALUES IN ("10"), + PARTITION p3 VALUES IN ("100","-10","2147483648"), + PARTITION p4 VALUES IN ("-100","0") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid list value format: errCode = 2, detailMessage = Number out of range[2147483648]. type: INT" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_5 ( + k1 INT NOT NULL, + v1 INT SUM NOT NULL, + v2 INT MAX NOT NULL, + v3 INT MIN NOT NULL, + v4 INT REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1","2","3"), + PARTITION p2 VALUES IN ("10"), + PARTITION p3 VALUES IN ("100","-10.01"), + PARTITION p4 VALUES IN ("-100","0") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid list value format: errCode = 2, detailMessage = Invalid number format: -10.01" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_6 ( + k1 INT NULL, + v1 INT SUM NULL, + v2 INT MAX NULL, + v3 INT MIN NULL, + v4 INT REPLACE NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1","2","3"), + PARTITION p2 VALUES IN ("10"), + PARTITION p3 VALUES IN ("100","-10"), + PARTITION p4 VALUES IN ("-100","0") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "The list partition column must be NOT NULL" + } + // date/datetime list partition errors like: conflict, invalid format + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_7 ( + k1 DATE NOT NULL, + v1 DATE REPLACE NOT NULL, + v2 DATE MAX NOT NULL, + v3 DATE MIN NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1990-01-01","2000-01-01"), + PARTITION p2 VALUES IN ("2000-01-01") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid list value format: errCode = 2, detailMessage = The partition key[('2000-01-01')] " + + "in partition item[('2000-01-01')] is conflict with current partitionKeys[(('1990-01-01'),('2000-01-01'))]" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_8 ( + k1 DATE NOT NULL, + v1 DATE REPLACE NOT NULL, + v2 DATE MAX NOT NULL, + v3 DATE MIN NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1990-01-01","2000-01-01"), + PARTITION p2 VALUES IN ("2000-01-02 08:00:00") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid list value format: errCode = 2, detailMessage = date literal [2000-01-02 08:00:00] " + + "is invalid: errCode = 2, detailMessage = Invalid date value: 2000-01-02 08:00:00" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_9 ( + k1 DATETIME NOT NULL, + v1 DATETIME REPLACE NOT NULL, + v2 DATETIME MAX NOT NULL, + v3 DATETIME MIN NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1990-01-01","2000-01-01"), + PARTITION p2 VALUES IN ("2000-01-02 08:00:00") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid list value format: errCode = 2, detailMessage = date literal [1990-01-01] is invalid: " + + "errCode = 2, detailMessage = Invalid datetime value: 1990-01-01" + } + // date boundary value & format test + sql "DROP TABLE IF EXISTS test_list_partition_ddl_tbl_1" + sql "DROP TABLE IF EXISTS test_list_partition_ddl_tbl_2" + sql """ + CREATE TABLE test_list_partition_ddl_tbl_1 ( + k1 DATE NOT NULL, + v1 DATE REPLACE NOT NULL ) + AGGREGATE KEY(k1) PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("0000-01-01","2000-01-01"), + PARTITION p2 VALUES IN ("20001102"), + PARTITION p3 VALUES IN ("9999-12-31") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + sql """INSERT INTO test_list_partition_ddl_tbl_1 VALUES("0000-01-01", "0000-01-01"), ("9999-12-31", "9999-12-31")""" + test { + sql """INSERT INTO test_list_partition_ddl_tbl_1 VALUES("2000-01-02", "2000-01-03")""" + exception "Insert has filtered data in strict mode" + } + qt_sql1 "SELECT * FROM test_list_partition_ddl_tbl_1 order by k1" + sql """INSERT INTO test_list_partition_ddl_tbl_1 VALUES("2000-11-02", "2000-11-03")""" + qt_sql2 "SELECT * FROM test_list_partition_ddl_tbl_1 order by k1" + + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_10 ( + k1 DATE NOT NULL, + v1 DATE REPLACE NOT NULL, + v2 DATE MAX NOT NULL, + v3 DATE MIN NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1990-01-01","2000-01-41"), + PARTITION p2 VALUES IN ("0000-01-01") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid list value format: errCode = 2, detailMessage = date literal [2000-01-41] is invalid: " + + "Text '2000-01-41' could not be parsed" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_11 ( + k1 DATE NOT NULL, + v1 DATE REPLACE NOT NULL, + v2 DATE MAX NOT NULL, + v3 DATE MIN NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1990-01-01","2000-01-01"), + PARTITION p2 VALUES IN ("10000-01-01") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid list value format: errCode = 2, detailMessage = date literal [10000-01-01] is invalid: " + + "errCode = 2, detailMessage = Datetime value is out of range" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_12 ( + k1 DATE NOT NULL, + v1 DATE REPLACE NOT NULL, + v2 DATE MAX NOT NULL, + v3 DATE MIN NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1990-01-01","2000-01-01"), + PARTITION p2 VALUES IN ("00-01-01") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid list value format: errCode = 2, detailMessage = The partition key[('2000-01-01')] " + + "in partition item[('00-01-01')] is conflict with current partitionKeys[(('1990-01-01'),('2000-01-01'))]" + } + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_13 ( + k1 DATE NOT NULL, + v1 DATE REPLACE NOT NULL, + v2 DATE MAX NOT NULL, + v3 DATE MIN NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("1990-01-01","2000-01-01"), + PARTITION p2 VALUES IN ("2000-1-1") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "The partition key[('2000-01-01')] in partition item[('2000-1-1')] is conflict with current " + + "partitionKeys[(('1990-01-01'),('2000-01-01'))]" + } + // 分区列的值溢出，string，前缀匹配，empty等 + // string list partition errors like: duplicate key, conflict, invalid format + test { + sql """ + CREATE TABLE test_list_partition_err_tbl_14 ( + k1 CHAR NOT NULL, v1 CHAR REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( + PARTITION p1 VALUES IN ("a","b"), + PARTITION p2 VALUES IN ("c"," ","?","a") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 + PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + exception "is conflict with current partitionKeys" + } + sql "DROP TABLE IF EXISTS test_list_partition_tb2_char" + sql """ + CREATE TABLE test_list_partition_tb2_char (k1 CHAR(5) NOT NULL, v1 CHAR(5) REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( PARTITION p1 VALUES IN ("a","b"), PARTITION p2 VALUES IN ("c"," ","?","ddd") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + test { + sql """insert into test_list_partition_tb2_char values('d', '1')""" + exception "Insert has filtered data in strict mode" + } + sql """alter table test_list_partition_tb2_char add partition partition_add_1 values in ("aaa","bbb")""" + def ret = sql "show partitions from test_list_partition_tb2_char where PartitionName='partition_add_1'" + assertTrue(ret.size() == 1) + + test { + sql """ insert into test_list_partition_tb2_char values('aa', '1')""" + exception "Insert has filtered data in strict mode" + } + sql "insert into test_list_partition_tb2_char values('a', 'a')" + sql "insert into test_list_partition_tb2_char values('aaa', 'a')" + sql "insert into test_list_partition_tb2_char values('aaa', 'b')" + sql "insert into test_list_partition_tb2_char values('?', 'a')" + qt_sql3 "select * from test_list_partition_tb2_char order by k1" + + sql "DROP TABLE IF EXISTS test_list_partition_empty_tb" + sql """ + CREATE TABLE test_list_partition_empty_tb ( + k1 char(5) NOT NULL, + v1 char(5) REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 properties ("replication_allocation" = "tag.location.default: 1") + """ + ret = sql "show partitions from test_list_partition_empty_tb" + assertTrue(ret.size() == 0) + sql """alter table test_list_partition_empty_tb add partition partition_add_2 values in ("ccc"," ","?","aaaa")""" + ret = sql "show partitions from test_list_partition_empty_tb" + assertTrue(ret.size() == 1) + sql "insert into test_list_partition_empty_tb values (' ', 'empty' ), ('ccc', '3c'), ('aaaa', '4a')" + qt_sql4 "select * from test_list_partition_empty_tb order by k1" + + // test add partition + sql "DROP TABLE IF EXISTS test_list_partition_tb3_char" + sql """ + CREATE TABLE test_list_partition_tb3_char (k1 CHAR NOT NULL, v1 CHAR REPLACE NOT NULL ) + AGGREGATE KEY(k1) + PARTITION BY LIST(k1) ( PARTITION p1 VALUES IN ("a","b"), PARTITION p2 VALUES IN ("c"," ","?","ddd") ) + DISTRIBUTED BY HASH(k1) BUCKETS 5 PROPERTIES ("replication_allocation" = "tag.location.default: 1") + """ + // todo: char(1) add partition value "aaa","bbb", should failed? + sql """alter table test_list_partition_tb3_char add partition partition_add_1 values in ("aaa","bbb")""" + ret = sql "show partitions from test_list_partition_tb3_char where PartitionName='partition_add_1'" + assertTrue(ret.size() == 1) + try_sql "DROP TABLE IF EXISTS test_list_partition_ddl_tbl_1" + try_sql "DROP TABLE IF EXISTS test_list_partition_empty_tb" + try_sql "DROP TABLE IF EXISTS test_list_partition_select_tb" + try_sql "DROP TABLE IF EXISTS test_list_partition_tb2_char" + // try_sql "DROP TABLE IF EXISTS test_list_partition_tb3_char" +} diff --git a/regression-test/suites/partition_p0/multi_partition/test_multi_column_partition.groovy b/regression-test/suites/partition_p0/multi_partition/test_multi_column_partition.groovy new file mode 100644 index 0000000000..8ef435cdf1 --- /dev/null +++ b/regression-test/suites/partition_p0/multi_partition/test_multi_column_partition.groovy @@ -0,0 +1,463 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +suite("test_multi_partition_key", "p0") { + def random = new Random() + sql "set enable_insert_strict=true" + def createTable = { String tableName, String partitionInfo /* param */ -> + sql """DROP TABLE IF EXISTS ${tableName} FORCE""" + sql """ + CREATE TABLE IF NOT EXISTS ${tableName} ( + k1 TINYINT NOT NULL, + k2 SMALLINT NOT NULL, + k3 INT NOT NULL, + k4 BIGINT NOT NULL, + k5 LARGEINT NOT NULL, + k6 DATETIME NOT NULL, + v1 DATE REPLACE NOT NULL, + v2 CHAR REPLACE NOT NULL, + v3 VARCHAR(4096) REPLACE NOT NULL, + v4 FLOAT SUM NOT NULL, + v5 DOUBLE SUM NOT NULL, + v6 DECIMAL(20,7) SUM NOT NULL ) + ${partitionInfo} + DISTRIBUTED BY HASH(k1,k2,k3) BUCKETS ${random.nextInt(300) + 1} + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + } + def testPartitionTbl = { String tableName, String partitionInfo, Boolean ifDropTbl /* param */ -> + createTable(tableName, partitionInfo) + streamLoad { + table tableName + set "column_separator", "," + file "partition_table.csv" + } + sql "sync" + test { + sql "select * from ${tableName} order by k1, k2" + resultFile "partition_table.out" + } + def result = sql "SHOW PARTITIONS FROM ${tableName}" + assertTrue(result.size() > 1) + if (ifDropTbl) { + try_sql """DROP TABLE ${tableName}""" + } + + } + // test multi partition columns + testPartitionTbl( + "test_multi_partition_key_1", + """ + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES LESS THAN ("-127","-127"), + PARTITION partition_b VALUES LESS THAN ("-1","-1"), + PARTITION partition_c VALUES LESS THAN ("0","-1"), + PARTITION partition_d VALUES LESS THAN ("0","0"), + PARTITION partition_e VALUES LESS THAN ("126","126"), + PARTITION partition_f VALUES LESS THAN ("127") )""", + true + ) + + // partition columns are int & datetime + test { + sql """ + CREATE TABLE err_1 ( + k1 TINYINT NOT NULL, + k5 DATETIME NOT NULL, + v1 DATE REPLACE NOT NULL) + PARTITION BY RANGE(k1,k5) ( + PARTITION partition_a VALUES LESS THAN ("-127","2010-01-01"), + PARTITION partition_e VALUES LESS THAN ("4","2010-01-01"), + PARTITION partition_f VALUES LESS THAN MAXVALUE ) + DISTRIBUTED BY HASH(k1) BUCKETS 53 + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + exception "Invalid datetime value: 2010-01-01" + } + testPartitionTbl( + "test_multi_partition_key_2", + """ + PARTITION BY RANGE(k1,k6) ( + PARTITION partition_a VALUES LESS THAN ("-127","2010-01-01 00:00:00"), + PARTITION partition_b VALUES LESS THAN ("1","2010-01-02 00:00:00"), + PARTITION partition_c VALUES LESS THAN ("2","2010-01-03 00:00:00"), + PARTITION partition_d VALUES LESS THAN ("3","2010-01-04 00:00:00"), + PARTITION partition_e VALUES LESS THAN ("4","2010-01-01 00:00:00"), + PARTITION partition_f VALUES LESS THAN MAXVALUE ) + """, + false + ) + qt_sql1 "select * from test_multi_partition_key_2 partition (partition_a) order by k1, k2 " + qt_sql2 "select * from test_multi_partition_key_2 partition (partition_b) order by k1, k2" + qt_sql3 "select * from test_multi_partition_key_2 partition (partition_c) order by k1, k2" + qt_sql4 "select * from test_multi_partition_key_2 partition (partition_d) order by k1, k2" + qt_sql5 "select * from test_multi_partition_key_2 partition (partition_e) order by k1, k2" + qt_sql6 "select * from test_multi_partition_key_2 partition (partition_f) order by k1, k2" + + // partition columns should be key in aggregate table + test { + sql """ + CREATE TABLE err_2 ( + k1 TINYINT NOT NULL, + v1 DATE REPLACE NOT NULL) + AGGREGATE KEY(k1) + PARTITION BY RANGE(k1,v1) ( + PARTITION partition_a VALUES LESS THAN ("-127","2010-01-01"), + PARTITION partition_e VALUES LESS THAN ("4","2010-01-01"), + PARTITION partition_f VALUES LESS THAN MAXVALUE ) + DISTRIBUTED BY HASH(k1) BUCKETS 226 + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + exception " The partition column could not be aggregated column" + } + // test the default value of partition value: minvalue + testPartitionTbl( + "test_default_minvalue", + """ + PARTITION BY RANGE(k2,k1) ( + PARTITION partition_a VALUES LESS THAN ("-127","-127"), + PARTITION partition_b VALUES LESS THAN ("-1","-1"), + PARTITION partition_c VALUES LESS THAN ("0"), + PARTITION partition_d VALUES LESS THAN ("0","0"), + PARTITION partition_e VALUES LESS THAN ("126","126"), + PARTITION partition_f VALUES LESS THAN ("500") ) + """, + false + ) + // expect partition_f range: [ [126, 126] ~ [500, -128] ) + def ret = sql "SHOW PARTITIONS FROM test_default_minvalue WHERE PartitionName='partition_f'" + assertTrue(ret[0][6].contains("[500, -128]")) + + // partition columns error + test { + sql """ + CREATE TABLE err_3 ( + k1 TINYINT NOT NULL, + v1 DATE REPLACE NOT NULL) + PARTITION BY RANGE(k1,k1) ( + PARTITION partition_a VALUES LESS THAN ("-127","1"), + PARTITION partition_f VALUES LESS THAN MAXVALUE ) + DISTRIBUTED BY HASH(k1) BUCKETS 68 + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + exception "Duplicated partition column k1" + } + // partition range intersected + test { + sql """ + CREATE TABLE err_4 ( + k1 TINYINT NOT NULL, + k2 SMALLINT NOT NULL, + v1 DATE REPLACE NOT NULL ) + AGGREGATE KEY(k1,k2) + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES LESS THAN ("-127"), + PARTITION partition_b VALUES LESS THAN ("5","0"), + PARTITION partition_c VALUES LESS THAN ("5","100"), + PARTITION partition_d VALUES LESS THAN ("5","10"), + PARTITION partition_f VALUES LESS THAN MAXVALUE ) + DISTRIBUTED BY HASH(k1) BUCKETS 258 + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + exception "Range [types: [TINYINT, SMALLINT]; keys: [5, 0]; ..types: [TINYINT, SMALLINT]; keys: [5, 10]; ) " + + "is intersected with range: " + + "[types: [TINYINT, SMALLINT]; keys: [5, 0]; ..types: [TINYINT, SMALLINT]; keys: [5, 100]; )" + } + // partition range error + test { + sql """ + CREATE TABLE err_5 ( + k1 TINYINT NOT NULL, + k2 SMALLINT NOT NULL, + v1 DATE REPLACE NOT NULL) + AGGREGATE KEY(k1,k2) + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES LESS THAN ("-127"), + PARTITION partition_b VALUES LESS THAN ("5","0"), + PARTITION partition_c VALUES LESS THAN ("5","100"), + PARTITION partition_d VALUES LESS THAN ("5","300"), + PARTITION partition_e VALUES LESS THAN ("5"), + PARTITION partition_f VALUES LESS THAN MAXVALUE ) + DISTRIBUTED BY HASH(k1) BUCKETS 268 + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + exception "[types: [TINYINT, SMALLINT]; keys: [-127, -32768]; ..types: [TINYINT, SMALLINT]; keys: [5, -32768]; )" + + " is intersected with range: " + + "[types: [TINYINT, SMALLINT]; keys: [-127, -32768]; ..types: [TINYINT, SMALLINT]; keys: [5, 0]; )" + } + // partitioned by multi columns and add partition + testPartitionTbl( + "test_multi_col_test_partition_add", + """ + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES LESS THAN ("-127","-127"), + PARTITION partition_b VALUES LESS THAN ("-1","-1"), + PARTITION partition_c VALUES LESS THAN ("0","-1"), + PARTITION partition_d VALUES LESS THAN ("0","0"), + PARTITION partition_e VALUES LESS THAN ("30"), + PARTITION partition_f VALUES LESS THAN ("30","500") ) + """, + false + ) + // error msg check + test { + sql "ALTER TABLE test_multi_col_test_partition_add ADD PARTITION partition_add VALUES LESS THAN ('30', '1000') " + + "DISTRIBUTED BY hash(k1) BUCKETS 5" + exception "Cannot assign hash distribution with different distribution cols. new is: [`k1` tinyint(4) NOT NULL] default is: [`k1` tinyint(4) NOT NULL]" + } + + sql "ALTER TABLE test_multi_col_test_partition_add ADD PARTITION partition_add VALUES LESS THAN ('30', '1000') " + def ret_add_p = sql "SHOW PARTITIONS FROM test_multi_col_test_partition_add WHERE PartitionName='partition_add'" + assertTrue(ret[0][6].contains("[500, -128]")) + test { + sql "ALTER TABLE test_multi_col_test_partition_add ADD PARTITION add_partition_wrong " + + "VALUES LESS THAN ('30', '800') DISTRIBUTED BY hash(k1) BUCKETS 5" + exception "is intersected with range" + } + // partitioned by multi columns and drop partition column + testPartitionTbl( + "test_multi_col_test_partition_drop", + """ + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES LESS THAN ("-127","-127"), + PARTITION partition_b VALUES LESS THAN ("-1","-1"), + PARTITION partition_c VALUES LESS THAN ("0","-1"), + PARTITION partition_d VALUES LESS THAN ("0","0"), + PARTITION partition_e VALUES LESS THAN ("30"), + PARTITION partition_f VALUES LESS THAN ("30","500") ) + """, + false + ) + sql "ALTER TABLE test_multi_col_test_partition_drop DROP PARTITION partition_d" + def ret_drop_p = sql "SHOW PARTITIONS FROM test_multi_col_test_partition_drop WHERE PartitionName='partition_d'" + assertEquals(0, ret_drop_p.size()) + sql "ALTER TABLE test_multi_col_test_partition_drop ADD PARTITION partition_dd VALUES LESS THAN ('0','0') " + ret_drop_p = sql "SHOW PARTITIONS FROM test_multi_col_test_partition_drop WHERE PartitionName='partition_dd'" + assertTrue(ret_drop_p[0][6].contains("[0, 0]")) + // null value in the lowest partition, if drop the partition null is deleted. + sql """drop table if exists test_multi_col_test_partition_null_value""" + sql """ + CREATE TABLE test_multi_col_test_partition_null_value ( + k1 TINYINT NULL, + k2 SMALLINT NULL, + k3 INT NULL, + k4 BIGINT NULL, + k5 LARGEINT NULL, + k6 DATETIME NULL, + v1 DATE REPLACE NULL, + v2 CHAR REPLACE NULL, + v3 VARCHAR(4096) REPLACE NULL, + v4 FLOAT SUM NULL, + v5 DOUBLE SUM NULL, + v6 DECIMAL(20,7) SUM NULL ) + + PARTITION BY RANGE(k2,k1) ( + PARTITION partition_a VALUES LESS THAN ("-127","-127"), + PARTITION partition_b VALUES LESS THAN ("-1","-1"), + PARTITION partition_c VALUES LESS THAN ("0"), + PARTITION partition_d VALUES LESS THAN ("0","0"), + PARTITION partition_e VALUES LESS THAN ("126","126"), + PARTITION partition_f VALUES LESS THAN ("500") ) + + DISTRIBUTED BY HASH(k1,k2,k3) BUCKETS 18 + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + sql "insert into test_multi_col_test_partition_null_value " + + "values(0, NULL, 0, 0, 0, '2000-01-01 00:00:00', '2000-01-01', 'a', 'a', 0.001, -0.001, 0.001)" + qt_sql7 "select k1 from test_multi_col_test_partition_null_value partition(partition_a) where k2 is null" + sql "ALTER TABLE test_multi_col_test_partition_null_value DROP PARTITION partition_a" + test { + sql "insert into test_multi_col_test_partition_null_value " + + "values(0, NULL, 0, 0, 0, '2000-01-01 00:00:00', '2000-01-01', 'a', 'a', 0.001, -0.001, 0.001)" + exception "Insert has filtered data in strict mode" + } + qt_sql8 "select k1 from test_multi_col_test_partition_null_value where k2 is null" + // partition columns and add key column + testPartitionTbl( + "test_multi_col_test_partition_key_add_col", + """ + PARTITION BY RANGE(k2,k1) ( + PARTITION partition_a VALUES LESS THAN ("-127","-127"), + PARTITION partition_b VALUES LESS THAN ("-1","-1"), + PARTITION partition_c VALUES LESS THAN ("0"), + PARTITION partition_d VALUES LESS THAN ("0","0"), + PARTITION partition_e VALUES LESS THAN ("126","126"), + PARTITION partition_f VALUES LESS THAN ("500") ) + """, + false + ) + sql "ALTER TABLE test_multi_col_test_partition_key_add_col ADD COLUMN add_key int NOT NULL DEFAULT '0' AFTER k1" + assertEquals("FINISHED", getAlterColumnFinalState("test_multi_col_test_partition_key_add_col")) + sql "insert into test_multi_col_test_partition_key_add_col " + + "values(0, 100, 0, 0, 0, 0, '2000-01-01 00:00:00', '2000-01-01', 'a', 'a', 0.001, -0.001, 0.001)" + qt_sql9 "select * from test_multi_col_test_partition_key_add_col order by k1, k2" + // can not drop partition column + testPartitionTbl( + "test_multi_column_drop_partition_column", + """ + PARTITION BY RANGE(k2,k1) ( + PARTITION partition_a VALUES LESS THAN ("-127","-127"), + PARTITION partition_b VALUES LESS THAN ("-1","-1"), + PARTITION partition_c VALUES LESS THAN ("0"), + PARTITION partition_d VALUES LESS THAN ("0","0"), + PARTITION partition_e VALUES LESS THAN ("126","126"), + PARTITION partition_f VALUES LESS THAN ("500") ) + """, + false + ) + test { + sql "ALTER TABLE test_multi_column_drop_partition_column DROP COLUMN k1" + exception "Can not drop key column when table has value column with REPLACE aggregation method" + } + // drop replace value + sql "ALTER TABLE test_multi_column_drop_partition_column DROP COLUMN v1, DROP COLUMN v2, DROP COLUMN v3" + assertEquals("FINISHED", getAlterColumnFinalState("test_multi_column_drop_partition_column")) + test { + sql "ALTER TABLE test_multi_column_drop_partition_column DROP COLUMN k1" + exception "Partition column[k1] cannot be dropped" + } + sql "insert into test_multi_column_drop_partition_column " + + "values(100, 0, 0, 0, 0, '2000-01-01 00:00:00', 0.001, -0.001, 0.001)" + qt_sql10 "select * from test_multi_column_drop_partition_column order by k2, k3, k4" + // test partition delete, todo: + sql "DELETE FROM test_multi_column_drop_partition_column PARTITION partition_d WHERE k2 = 10 AND k3 > 10" + qt_sql11 "select * from test_multi_column_drop_partition_column order by k2, k3, k4" + // test partition rollup, create & drop + testPartitionTbl( + 'test_multi_col_test_rollup', + """ + PARTITION BY RANGE(k2,k1) ( + PARTITION partition_a VALUES LESS THAN ("-127","-127"), + PARTITION partition_b VALUES LESS THAN ("-1","-1"), + PARTITION partition_c VALUES LESS THAN ("10"), + PARTITION partition_d VALUES LESS THAN ("10","1"), + PARTITION partition_e VALUES LESS THAN ("126","126"), + PARTITION partition_f VALUES LESS THAN ("500") ) + """, + false + ) + sql "ALTER TABLE test_multi_col_test_rollup ADD ROLLUP idx (k1,k3,k4,v5)" + assertEquals("FINISHED", getAlterRollupFinalState("test_multi_col_test_rollup")) + List> table_schema = sql "desc test_multi_col_test_rollup all" + assertEquals(17, table_schema.size()) + assertEquals("idx", table_schema[13][0]) + // test partition drop rollup, + sql "ALTER TABLE test_multi_col_test_rollup DROP ROLLUP idx" + assertEquals("FINISHED", getAlterRollupFinalState("test_multi_col_test_rollup")) + table_schema = sql "desc test_multi_col_test_rollup all" + assertEquals(12, table_schema.size()) + qt_sql12 "select * from test_multi_col_test_rollup order by k1, k2" + // test partition modify, check partition replication_num + sql "ALTER TABLE test_multi_col_test_rollup MODIFY PARTITION partition_a SET( 'replication_num' = '1')" + ret = sql "SHOW PARTITIONS FROM test_multi_col_test_rollup WHERE PartitionName='partition_a'" + assertEquals('1', ret[0][9]) + // create table with range partition + testPartitionTbl( + "test_multi_column_fixed_range_1", + """ + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES [("-127","-127"), ("10","-1")), + PARTITION partition_b VALUES [("10","-1"), ("40","0")), + PARTITION partition_c VALUES [("126","126"), ("127")) ) + """, + true + ) + + // partition value range + testPartitionTbl( + "test_multi_column_fixed_range_1", + """ + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES [("-127","-127"), ("10","10")), + PARTITION partition_b VALUES [("10","100"), ("40","0")), + PARTITION partition_c VALUES [("126","126"), ("127")) ) + """, + false + ) + test { + sql """ + CREATE TABLE IF NOT EXISTS test_multi_col_ddd ( + k1 TINYINT NOT NULL, + k2 SMALLINT NOT NULL) + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES [("-127","-127"), ("10", MAXVALUE)), + PARTITION partition_b VALUES [("10","100"), ("40","0")), + PARTITION partition_c VALUES [("126","126"), ("127")) ) + DISTRIBUTED BY HASH(k1,k2) BUCKETS 1 + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + exception "Not support MAXVALUE in multi partition range values" + } + // add partition with range + sql "ALTER TABLE test_multi_column_fixed_range_1 ADD PARTITION partition_add VALUES LESS THAN ('50','1000') " + ret = sql "SHOW PARTITIONS FROM test_multi_column_fixed_range_1 WHERE PartitionName='partition_add'" + assertEquals(1, ret.size(), ) + test { + sql "ALTER TABLE test_multi_column_fixed_range_1 ADD PARTITION add_partition_wrong VALUES LESS THAN ('50','800')" + exception "is intersected with range" + } + // test multi column insert + sql """drop table if exists test_multi_col_insert""" + sql """ + CREATE TABLE IF NOT EXISTS test_multi_col_insert ( + k1 TINYINT NOT NULL, + k2 SMALLINT NOT NULL) + PARTITION BY RANGE(k1,k2) ( + PARTITION partition_a VALUES [("-127","-127"), ("10","10")), + PARTITION partition_b VALUES [("10","100"), ("40","0")), + PARTITION partition_c VALUES [("126","126"), ("127")) ) + DISTRIBUTED BY HASH(k1,k2) BUCKETS 1 + PROPERTIES("replication_allocation" = "tag.location.default: 1") + """ + test { + sql "insert into test_multi_col_insert values (-127, -200)" + exception "Insert has filtered data in strict mode" + } + sql "insert into test_multi_col_insert values (10, -100)" + test { + sql "insert into test_multi_col_insert values (10, 50)" + exception "Insert has filtered data in strict mode" + + } + sql "insert into test_multi_col_insert values (10, 100)" + sql "insert into test_multi_col_insert values (30, -32768)" + test { + sql "insert into test_multi_col_insert values (30, -32769)" + exception "Number out of range[-32769]. type: SMALLINT" + } + test { + sql "insert into test_multi_col_insert values (50, -300)" + exception "Insert has filtered data in strict mode" + } + test { + sql "insert into test_multi_col_insert values (127, -300)" + exception "Insert has filtered data in strict mode" + } + qt_sql13 "select * from test_multi_col_insert order by k1, k2" + + try_sql "drop table if exists test_default_minvalue" + try_sql "drop table if exists test_multi_col_insert" + try_sql "drop table if exists test_multi_col_test_partition_add" + try_sql "drop table if exists test_multi_col_test_partition_drop" + try_sql "drop table if exists test_multi_col_test_partition_key_add_col" + try_sql "drop table if exists test_multi_col_test_partition_null_value" + try_sql "drop table if exists test_multi_col_test_rollup" + try_sql "drop table if exists test_multi_column_drop_partition_column" + try_sql "drop table if exists test_multi_column_fixed_range_1" + try_sql "drop table if exists test_multi_partition_key_2" + +}