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

[regression-test] add list partition case and multi partition keys case (#22042)

Browse Source 
* [regression-test] add list partition case and multi partition keys case

* fix delete failed
This commit is contained in:
zhangy5
2023-07-28 10:12:35 +08:00
committed by GitHub
parent 0d7d9b92db
commit adc44d9f46
8 changed files with 1348 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
regression-test/data/partition_p0/list_partition/expect_baseall.out Normal file
View File

@ -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

49
regression-test/data/partition_p0/list_partition/test_list_partition.out
View File

@ -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 --

20
regression-test/data/partition_p0/list_partition/test_list_partition_datatype.out Normal file
View File

@ -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

184
regression-test/data/partition_p0/multi_partition/test_multi_column_partition.out Normal file
View File

@ -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

86
regression-test/plugins/plugin_async_job_wait.groovy Normal file
View File

@ -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")

11
regression-test/suites/partition_p0/list_partition/test_list_partition.groovy
View File

@ -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;"
}

523
regression-test/suites/partition_p0/list_partition/test_list_partition_datatype.groovy Normal file
View File

@ -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"
}

463
regression-test/suites/partition_p0/multi_partition/test_multi_column_partition.groovy Normal file
View File

@ -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<List<Object>> 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"
}