Merge pull request #2040 from tntnatbry/MCOL-641-move-mtr-tests

MCOL-641 Move MTR tests from future/ to basic/
2025-07-29 08:21:15 +03:00 · 2021-07-12 15:47:45 -05:00
parent 51e9ff4ecb 78dbf3a7e1
commit 10cc1159a2
22 changed files with 19 additions and 17 deletions
--- a/mysql-test/columnstore/basic/t/mcol641-aggregate.test
+++ b/mysql-test/columnstore/basic/t/mcol641-aggregate.test
@ -0,0 +1,223 @@
+#source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS test_mcol641_aggregate;
+--enable_warnings
+
+CREATE DATABASE test_mcol641_aggregate;
+USE test_mcol641_aggregate;
+
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+DROP TABLE IF EXISTS cs2;
+DROP TABLE IF EXISTS cs3;
+DROP TABLE IF EXISTS cs4;
+DROP TABLE IF EXISTS cs5;
+--enable_warnings
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38), d4 DECIMAL(38),d5 DECIMAL(38),i1 INT) ENGINE=columnstore;
+CREATE TABLE cs2 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED, d4 DECIMAL(38),d5 DECIMAL(38),i1 INT) ENGINE=columnstore;
+CREATE TABLE cs3 (d1 DECIMAL(19), d2 DECIMAL(19,10), d3 DECIMAL(19,19), d4 DECIMAL(19),d5 DECIMAL(19),i1 INT) ENGINE=columnstore;
+CREATE TABLE cs4 (d1 DECIMAL(19) UNSIGNED, d2 DECIMAL(19,10) UNSIGNED, d3 DECIMAL(19,19) UNSIGNED, d4 DECIMAL(19) UNSIGNED,d5 DECIMAL(19),i1 INT) ENGINE=columnstore;
+CREATE TABLE cs5(d DECIMAL(25,19)) ENGINE=columnstore;
+
+INSERT INTO cs1 VALUES
+    (1234,5678,-0.12345678901234567890123456789018,2,1,1),     
+    (1234,-5678,0.1234567890123456789012345,2,1,1),
+    (12345678901234567890123,1234567890123456789012.9012345678,0.123456789012345678901234567890,2,1,1),
+    (NULL,NULL,NULL,2,1,1),
+    (0,0,0,2,1,1),
+    (1234,5678,0.1234567890123456783456789012345678,3,2,2),
+    (-123456789123456789,-5678,0.123456789012345673456789012345678,3,2,2),
+    (12345678901234567890901,1234567890123478901234.9012345678,0.1234567890123456789012345678908,3,2,2),
+    (NULL,NULL,NULL,3,2,2),
+    (0,0,0,3,2,2),
+    (1234,5678,-0.12345678901234567890123456789018,11111111111111111111111111111111,1,1),
+    (1234,5678,-0.12345678901234567890123456789018,11111111111111111111111111111111,1,1),
+    (1234,5678,-0.12345678901234567890123456789018,11111111111111111111111111111112,1,1); 
+INSERT INTO cs2 VALUES
+    (1234,5678,0.12345678901234567890123456789018,2,1,1),     
+    (1234,5678,0.1234567890123456789012345,2,1,1),
+    (12345678901234567890123,1234567890123456789012.9012345678,0.123456789012345678901234567890,2,1,1),
+    (NULL,NULL,NULL,2,1,1),
+    (0,0,0,2,1,1),
+    (1234,5678,0.1234567890123456783456789012345678,3,2,2),
+    (123456789123456789123,5678,0.123456789012345673456789012345678,3,2,2),
+    (12345678901234567890901,1234567890123478901234.9012345678,0.1234567890123456789012345678908,3,2,2),
+    (NULL,NULL,NULL,3,2,2),
+    (0,0,0,3,2,2),
+    (1234,5678,0.12345678901234567890123456789018,11111111111111111111111111111111,1,1),
+    (1234,5678,0.12345678901234567890123456789018,11111111111111111111111111111111,1,1),
+    (1234,5678,0.12345678901234567890123456789018,11111111111111111111111111111112,1,1); 
+INSERT INTO cs3 VALUES
+    (1234,5678,-0.12345678901234,2,1,1),     
+    (1234,-5678,0.12345678901234,2,1,1),
+    (12345678901,12345678.90128,0.1234567890123,2,1,1),
+    (NULL,NULL,NULL,2,1,1),
+    (0,0,0,2,1,1),
+    (1234,5678,0.12345678901234,3,2,2),
+    (-1234567899,-5678,0.1234567890123,3,2,2),
+    (12345678901,12345678.9012,0.1234567890123,3,2,2),
+    (NULL,NULL,NULL,3,2,2),
+    (0,0,0,3,2,2);
+INSERT INTO cs4 VALUES
+    (1234,5678,0.12345678901234,2,1,1),     
+    (1234,5678,0.12345678901234,2,1,1),
+    (12345678901,12345678.90128,0.1234567890123,2,1,1),
+    (NULL,NULL,NULL,2,1,1),
+    (0,0,0,2,1,1),
+    (1234,5678,0.12345678901234,3,2,2),
+    (1234567899,5678,0.1234567890123,3,2,2),
+    (12345678901,12345678.90123,0.1234567890123,3,2,2),
+    (NULL,NULL,NULL,3,2,2),
+    (0,0,0,3,2,2);
+
+#no GROUP BY DECIMAL(38)
+SELECT "sum(38)_test1", sum(d1),sum(d2),sum(d3) FROM cs1;
+SELECT "avg(38)_test1", avg(d1),avg(d2),avg(d3) FROM cs1;
+SELECT "count(38)_test1", count(d1),count(d2),count(d3) FROM cs1;
+SELECT "min(38)_test1", min(d1),min(d2),min(d3) FROM cs1;
+SELECT "max(38)_test1", max(d1),max(d2),max(d3) FROM cs1;
+SELECT "group_concat(38)_test1", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs1;
+SELECT "count(distinct 38)_test1", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs1;
+#no GROUP BY DECIMAL(38) UM 1phase aggregates
+SELECT "sum(38)_test1", sum(d1),sum(d2),sum(d3) FROM (SELECT d1,d2,d3 FROM cs1)a1;
+SELECT "avg(38)_test1", avg(d1),avg(d2),avg(d3) FROM (SELECT d1,d2,d3 FROM cs1)a1;
+SELECT "count(38)_test1", count(d1),count(d2),count(d3) FROM (SELECT d1,d2,d3 FROM cs1)a1;
+SELECT "min(38)_test1", min(d1),min(d2),min(d3) FROM (SELECT d1,d2,d3 FROM cs1)a1;
+SELECT "max(38)_test1", max(d1),max(d2),max(d3) FROM (SELECT d1,d2,d3 FROM cs1)a1;
+#Next two are proccessed by UM anyway
+SELECT "group_concat(38)_test1", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM (SELECT d1,d2,d3 FROM cs1)a1;
+SELECT "count(distinct 38)_test1", count(distinct d1),count(distinct d2),count(distinct d3) FROM (SELECT d1,d2,d3 FROM cs1)a1;
+#GROUP BY DECIMAL(38)
+SELECT "sum(38)_GB(38)_test1" ,d4,d5,sum(d1),sum(d2),sum(d3) FROM cs1 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "avg(38)_GB(38)_test1" ,d4,d5,avg(d1),avg(d2),avg(d3) FROM cs1 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "count(38)_GB(38)_test1" ,d4,d5,count(d1),count(d2),count(d3) FROM cs1 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "min(38)_GB(38)_test1" ,d4,d5,min(d1),min(d2),min(d3) FROM cs1 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "max(38)_GB(38)_test1" ,d4,d5,max(d1),max(d2),max(d3) FROM cs1 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "group_concat(38)_GB(38)_test1", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs1 GROUP BY d4,d5 ORDER BY 2;
+SELECT "count(distinct 38)_GB(38)_test1", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs1 GROUP BY d4,d5 ORDER BY 2,3;
+#with GROUP BY INT
+SELECT "sum(38)_GB(8)_test1" ,i1,sum(d1),sum(d2),sum(d3) FROM cs1 GROUP BY i1 ORDER BY 2;
+SELECT "avg(38)_GB(8)_test1" ,i1,avg(d1),avg(d2),avg(d3) FROM cs1 GROUP BY i1 ORDER BY 2;
+SELECT "count(38)_GB(8)_test1" ,i1,count(d1),count(d2),count(d3) FROM cs1 GROUP BY i1 ORDER BY 2;
+SELECT "min(38)_GB(8)_test1" ,i1,min(d1),min(d2),min(d3) FROM cs1 GROUP BY i1 ORDER BY 2;
+SELECT "max(38)_GB(8)_test1" ,i1,max(d1),max(d2),max(d3) FROM cs1 GROUP BY i1 ORDER BY 2;
+SELECT "group_concat(38)_GB(8)_test1", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs1 GROUP BY i1 ORDER BY 2;
+SELECT "count(distinct 38)_GB(8)_test1", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs1 GROUP BY i1 ORDER BY 2;
+
+#no GROUP BY UDECIMAL(38,10)
+SELECT "sum(38)_test2", sum(d1),sum(d2),sum(d3) FROM cs2;
+SELECT "avg(38)_test2", avg(d1),avg(d2),avg(d3) FROM cs2;
+SELECT "count(38)_test2", count(d1),count(d2),count(d3) FROM cs2;
+SELECT "min(38)_test2", min(d1),min(d2),min(d3) FROM cs2;
+SELECT "max(38)_test2", max(d1),max(d2),max(d3) FROM cs2;
+SELECT "group_concat(38)_test2", group_concat(d1),group_concat(d2),group_concat(d3) FROM cs2;
+SELECT "count(distinct 38)_test2", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs2;
+#no GROUP BY UDECIMAL(38) UM 1phase aggregates
+SELECT "sum(38)_test2", sum(d1),sum(d2),sum(d3) FROM (SELECT d1,d2,d3 FROM cs2)a1;
+SELECT "avg(38)_test2", avg(d1),avg(d2),avg(d3) FROM (SELECT d1,d2,d3 FROM cs2)a1;
+SELECT "count(38)_test2", count(d1),count(d2),count(d3) FROM (SELECT d1,d2,d3 FROM cs2)a1;
+SELECT "min(38)_test2", min(d1),min(d2),min(d3) FROM (SELECT d1,d2,d3 FROM cs2)a1;
+SELECT "max(38)_test2", max(d1),max(d2),max(d3) FROM (SELECT d1,d2,d3 FROM cs2)a1;
+SELECT "group_concat(38)_test2", group_concat(d1),group_concat(d2),group_concat(d3) FROM (SELECT d1,d2,d3 FROM cs2)a1;
+SELECT "count(distinct 38)_test2", count(distinct d1),count(distinct d2),count(distinct d3) FROM (SELECT d1,d2,d3 FROM cs2)a1;
+#GROUP BY DECIMAL(38)
+SELECT "sum(38)_GB(38)_test2" ,d4,d5,sum(d1),sum(d2),sum(d3) FROM cs2 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "avg(38)_GB(38)_test2" ,d4,d5,avg(d1),avg(d2),avg(d3) FROM cs2 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "count(38)_GB(38)_test2" ,d4,d5,count(d1),count(d2),count(d3) FROM cs2 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "min(38)_GB(38)_test2" ,d4,d5,min(d1),min(d2),min(d3) FROM cs2 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "max(38)_GB(38)_test2" ,d4,d5,max(d1),max(d2),max(d3) FROM cs2 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "group_concat(38)_GB(38)_test2", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs2 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "count(distinct 38)_GB(38)_test2", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs2 GROUP BY d4,d5 ORDER BY 2,3;
+#with GROUP BY INT
+SELECT "sum(38)_GB(8)_test2" ,i1,sum(d1),sum(d2),sum(d3) FROM cs2 GROUP BY i1 ORDER BY 2,3;
+SELECT "avg(38)_GB(8)_test2" ,i1,avg(d1),avg(d2),avg(d3) FROM cs2 GROUP BY i1 ORDER BY 2,3;
+SELECT "count(38)_GB(8)_test2" ,i1,count(d1),count(d2),count(d3) FROM cs2 GROUP BY i1 ORDER BY 2,3;
+SELECT "min(38)_GB(8)_test2" ,i1,min(d1),min(d2),min(d3) FROM cs2 GROUP BY i1 ORDER BY 2,3;
+SELECT "max(38)_GB(8)_test2" ,i1,max(d1),max(d2),max(d3) FROM cs2 GROUP BY i1 ORDER BY 2,3;
+SELECT "group_concat(38)_GB(8)_test2", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d1),group_concat(d3 ORDER BY d1) FROM cs2 GROUP BY i1 ORDER BY 2,3;
+SELECT "count(distinct 38)_GB(8)_test2", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs2 GROUP BY i1 ORDER BY 2,3;
+
+#no GROUP BY DECIMAL(19)
+SELECT "sum(19)_test3", sum(d1),sum(d2),sum(d3) FROM cs3;
+SELECT "avg(19)_test3", avg(d1),avg(d2),avg(d3) FROM cs3;
+SELECT "count(19)_test3", count(d1),count(d2),count(d3) FROM cs3;
+SELECT "min(19)_test3", min(d1),min(d2),min(d3) FROM cs3;
+SELECT "max(19)_test3", max(d1),max(d2),max(d3) FROM cs3;
+SELECT "group_concat(38)_test3", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d1),group_concat(d3 ORDER BY d1) FROM cs3;
+SELECT "count(distinct 38)_test3", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs3;
+#no GROUP BY DECIMAL(19) UM 1phase aggregates
+SELECT "sum(19)_test3", sum(d1),sum(d2),sum(d3) FROM (SELECT d1,d2,d3 FROM cs3)a1;
+SELECT "avg(19)_test3", avg(d1),avg(d2),avg(d3) FROM (SELECT d1,d2,d3 FROM cs3)a1;
+SELECT "count(19)_test3", count(d1),count(d2),count(d3) FROM (SELECT d1,d2,d3 FROM cs3)a1;
+SELECT "min(19)_test3", min(d1),min(d2),min(d3) FROM (SELECT d1,d2,d3 FROM cs3)a1;
+SELECT "max(19)_test3", max(d1),max(d2),max(d3) FROM (SELECT d1,d2,d3 FROM cs3)a1;
+SELECT "group_concat(38)_test3", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM (SELECT d1,d2,d3 FROM cs3)a1;
+SELECT "count(distinct 38)_test3", count(distinct d1),count(distinct d2),count(distinct d3) FROM (SELECT d1,d2,d3 FROM cs3)a1;
+#GROUP BY DECIMAL(38)
+SELECT "sum(38)_GB(38)_test3" ,d4,d5,sum(d1),sum(d2),sum(d3) FROM cs3 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "avg(38)_GB(38)_test3" ,d4,d5,avg(d1),avg(d2),avg(d3) FROM cs3 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "count(38)_GB(38)_test3" ,d4,d5,count(d1),count(d2),count(d3) FROM cs3 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "min(38)_GB(38)_test3" ,d4,d5,min(d1),min(d2),min(d3) FROM cs3 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "max(38)_GB(38)_test3" ,d4,d5,max(d1),max(d2),max(d3) FROM cs3 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "group_concat(38)_GB(38)_test3", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs3 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "count(distinct 38)_GB(38)_test3", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs3 GROUP BY d4,d5 ORDER BY 2,3;
+#with GROUP BY INT
+SELECT "sum(38)_GB(8)_test3" ,i1,sum(d1),sum(d2),sum(d3) FROM cs3 GROUP BY i1 ORDER BY 2,3;
+SELECT "avg(38)_GB(8)_test3" ,i1,avg(d1),avg(d2),avg(d3) FROM cs3 GROUP BY i1 ORDER BY 2,3;
+SELECT "count(38)_GB(8)_test3" ,i1,count(d1),count(d2),count(d3) FROM cs3 GROUP BY i1 ORDER BY 2,3;
+SELECT "min(38)_GB(8)_test3" ,i1,min(d1),min(d2),min(d3) FROM cs3 GROUP BY i1 ORDER BY 2,3;
+SELECT "max(38)_GB(8)_test3" ,i1,max(d1),max(d2),max(d3) FROM cs3 GROUP BY i1 ORDER BY 2,3;
+SELECT "group_concat(38)_GB(8)_test3", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs3 GROUP BY i1 ORDER BY 2,3;
+SELECT "count(distinct 38)_GB(8)_test3", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs3 GROUP BY i1 ORDER BY 2,3;
+
+#no GROUP BY UDECIMAL(19)
+SELECT "sum(19)_test4", sum(d1),sum(d2),sum(d3) FROM cs4;
+SELECT "avg(19)_test4", avg(d1),avg(d2),avg(d3) FROM cs4;
+SELECT "count(19)_test4", count(d1),count(d2),count(d3) FROM cs4;
+SELECT "min(19)_test4", min(d1),min(d2),min(d3) FROM cs4;
+SELECT "max(19)_test4", max(d1),max(d2),max(d3) FROM cs4;
+SELECT "group_concat(38)_test4", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs4;
+SELECT "count(distinct 38)_test4", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs4;
+#no GROUP BY UDECIMAL(19) UM 1phase aggregates
+SELECT "sum(19)_test4", sum(d1),sum(d2),sum(d3) FROM (SELECT d1,d2,d3 FROM cs4)a1;
+SELECT "avg(19)_test4", avg(d1),avg(d2),avg(d3) FROM (SELECT d1,d2,d3 FROM cs4)a1;
+SELECT "count(19)_test4", count(d1),count(d2),count(d3) FROM (SELECT d1,d2,d3 FROM cs4)a1;
+SELECT "min(19)_test4", min(d1),min(d2),min(d3) FROM (SELECT d1,d2,d3 FROM cs4)a1;
+SELECT "max(19)_test4", max(d1),max(d2),max(d3) FROM (SELECT d1,d2,d3 FROM cs4)a1;
+SELECT "group_concat(38)_test4", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM (SELECT d1,d2,d3 FROM cs4)a1;
+SELECT "count(distinct 38)_test4", count(distinct d1),count(distinct d2),count(distinct d3) FROM (SELECT d1,d2,d3 FROM cs4)a1;
+#GROUP BY DECIMAL(38)
+SELECT "sum(38)_GB(38)_test4" ,d4,d5,sum(d1),sum(d2),sum(d3) FROM cs4 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "avg(38)_GB(38)_test4" ,d4,d5,avg(d1),avg(d2),avg(d3) FROM cs4 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "count(38)_GB(38)_test4" ,d4,d5,count(d1),count(d2),count(d3) FROM cs4 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "min(38)_GB(38)_test4" ,d4,d5,min(d1),min(d2),min(d3) FROM cs4 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "max(38)_GB(38)_test4" ,d4,d5,max(d1),max(d2),max(d3) FROM cs4 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "group_concat(38)_GB(38)_test4", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs4 GROUP BY d4,d5 ORDER BY 2,3;
+SELECT "count(distinct 38)_GB(38)_test4", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs4 GROUP BY d4,d5 ORDER BY 2,3;
+#with GROUP BY INT
+SELECT "sum(38)_GB(38)_test4" ,i1,sum(d1),sum(d2),sum(d3) FROM cs4 GROUP BY i1 ORDER BY 2,3;
+SELECT "avg(38)_GB(38)_test4" ,i1,avg(d1),avg(d2),avg(d3) FROM cs4 GROUP BY i1 ORDER BY 2,3;
+SELECT "count(38)_GB(38)_test4" ,i1,count(d1),count(d2),count(d3) FROM cs4 GROUP BY i1 ORDER BY 2,3;
+SELECT "min(38)_GB(38)_test4" ,i1,min(d1),min(d2),min(d3) FROM cs4 GROUP BY i1 ORDER BY 2,3;
+SELECT "max(38)_GB(38)_test4" ,i1,max(d1),max(d2),max(d3) FROM cs4 GROUP BY i1 ORDER BY 2,3;
+SELECT "group_concat(38)_GB(8)_test4", group_concat(d1 ORDER BY d1),group_concat(d2 ORDER BY d2),group_concat(d3 ORDER BY d3) FROM cs4 GROUP BY i1 ORDER BY 2,3;
+SELECT "count(distinct 38)_GB(8)_test4", count(distinct d1),count(distinct d2),count(distinct d3) FROM cs4 GROUP BY i1 ORDER BY 2,3;
+
+#non-first const column
+SELECT sum(d1), "sum(38)_test1", sum(d2),sum(d3) FROM cs1;
+#rounding for AVG
+#The last digit rounding is an open question for aggregates.
+INSERT INTO cs5 VALUES (1),(0.1),(0.05),(0.05),(0.05),(0.05),(0.2),(0.154),(0.1),(0.05),(0.05);
+SELECT avg(d) FROM cs5;
+UPDATE cs5 SET d=-d;
+SELECT avg(d) FROM cs5;
+
+#Add HAVING with GB  
+
+DROP TABLE cs1;
+DROP TABLE cs2;
+DROP TABLE cs3;
+DROP TABLE cs4;
+DROP TABLE cs5;
--- a/mysql-test/columnstore/basic/t/mcol641-arithmetic.test
+++ b/mysql-test/columnstore/basic/t/mcol641-arithmetic.test
@ -0,0 +1,309 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS mcol641_arithmetic_db;
+--enable_warnings
+
+CREATE DATABASE mcol641_arithmetic_db;
+USE mcol641_arithmetic_db;
+
+--disable_warnings
+DROP PROCEDURE IF EXISTS deleteproc;
+--enable_warnings
+
+DELIMITER //;
+
+CREATE PROCEDURE deleteproc ()
+ BEGIN
+  DELETE FROM cs1;
+  DELETE FROM cs2;
+  DELETE FROM cs3;
+  DELETE FROM cs4;
+  DELETE FROM cs5;
+  DELETE FROM cs6;
+  DELETE FROM cs7;
+  DELETE FROM cs8;
+  DELETE FROM cs9;
+  DELETE FROM cs10;
+  DELETE FROM cs11;
+  DELETE FROM cs12;
+ END//
+
+DELIMITER ;//
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38)) ENGINE=columnstore;
+CREATE TABLE cs2 (d1 DECIMAL(19), d2 DECIMAL(19)) ENGINE=columnstore;
+CREATE TABLE cs3 (d1 DECIMAL(38), d2 DECIMAL(19)) ENGINE=columnstore;
+CREATE TABLE cs4 (d1 DECIMAL(38), d2 DECIMAL(10)) ENGINE=columnstore;
+CREATE TABLE cs5 (d1 DECIMAL(38,10), d2 DECIMAL(38,10)) ENGINE=columnstore;
+CREATE TABLE cs6 (d1 DECIMAL(19,10), d2 DECIMAL(19,10)) ENGINE=columnstore;
+CREATE TABLE cs7 (d1 DECIMAL(38,10), d2 DECIMAL(19,10)) ENGINE=columnstore;
+CREATE TABLE cs8 (d1 DECIMAL(38,10), d2 DECIMAL(10,10)) ENGINE=columnstore;
+CREATE TABLE cs9 (d1 DECIMAL(38,38), d2 DECIMAL(38,38)) ENGINE=columnstore;
+CREATE TABLE cs10 (d1 DECIMAL(19,19), d2 DECIMAL(19,19)) ENGINE=columnstore;
+CREATE TABLE cs11 (d1 DECIMAL(38,38), d2 DECIMAL(19,19)) ENGINE=columnstore;
+CREATE TABLE cs12 (d1 DECIMAL(38,38), d2 DECIMAL(10,10)) ENGINE=columnstore;
+
+# Addition
+# without overflow check
+SET columnstore_decimal_overflow_check=off;
+INSERT INTO cs1 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs1 VALUES (12345678901234567890123456789012345678, 12345678901234567890123456789012345678), (12345678901234567890123456789012345678, -22345678901234567890123456789012345678);
+INSERT INTO cs1 VALUES (99999999999999999999999999999999999998, 1), (-99999999999999999999999999999999999998, -1);
+SELECT "add_test_38_0_38_0", d1 + d2 FROM cs1;
+INSERT INTO cs2 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs2 VALUES (1234567890123456789, 1234567890123456789), (1234567890123456789, -2234567890123456789);
+INSERT INTO cs2 VALUES (9999999999999999998, 1), (-9999999999999999998, -1);
+SELECT "add_test_19_0_19_0", d1 + d2 FROM cs2;
+INSERT INTO cs3 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs3 VALUES (12345678901234567890123456789012345678, 1234567890123456789), (12345678901234567890123456789012345678, -2234567890123456789);
+INSERT INTO cs3 VALUES (99999999999999999999999999999999999998, 1), (-99999999999999999999999999999999999998, -1);
+SELECT "add_test_38_0_19_0", d1 + d2 FROM cs3;
+INSERT INTO cs4 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs4 VALUES (12345678901234567890123456789012345678, 1234567890), (12345678901234567890123456789012345678, -2234567890);
+INSERT INTO cs4 VALUES (99999999999999999999999999999999999998, 1), (-99999999999999999999999999999999999998, -1);
+SELECT "add_test_38_0_10_0", d1 + d2 FROM cs4;
+INSERT INTO cs5 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs5 VALUES (1234567890123456789012345678.9012345678, 1234567890123456789012345678.9012345678), (1234567890123456789012345678.9012345678, -2234567890123456789012345678.9012345678);
+INSERT INTO cs5 VALUES (9999999999999999999999999999.9999999998, 0.0000000001), (-9999999999999999999999999999.9999999998, -0.0000000001);
+SELECT "add_test_38_10_38_10", d1 + d2 FROM cs5;
+INSERT INTO cs6 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs6 VALUES (123456789.0123456789, 123456789.0123456789), (123456789.0123456789, -223456789.0123456789);
+INSERT INTO cs6 VALUES (999999999.9999999998, 0.0000000001), (-999999999.9999999998, -0.0000000001);
+SELECT "add_test_19_10_19_10", d1 + d2 FROM cs6;
+INSERT INTO cs7 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs7 VALUES (1234567890123456789012345678.9012345678, 123456789.0123456789), (1234567890123456789012345678.9012345678, -223456789.0123456789);
+INSERT INTO cs7 VALUES (9999999999999999999999999999.9999999998, 0.0000000001), (-9999999999999999999999999999.9999999998, -0.0000000001);
+SELECT "add_test_38_10_19_10", d1 + d2 FROM cs7;
+INSERT INTO cs8 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs8 VALUES (1234567890123456789012345678.9012345678, 0.1234567890), (1234567890123456789012345678.9012345678, -0.2234567890);
+INSERT INTO cs8 VALUES (9999999999999999999999999999.9999999998, 0.0000000001), (-9999999999999999999999999999.9999999998, -0.0000000001);
+SELECT "add_test_38_10_10_10", d1 + d2 FROM cs8;
+INSERT INTO cs9 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs9 VALUES (0.12345678901234567890123456789012345678, 0.12345678901234567890123456789012345678), (0.12345678901234567890123456789012345678, -0.22345678901234567890123456789012345678);
+INSERT INTO cs9 VALUES (0.99999999999999999999999999999999999998, 0.00000000000000000000000000000000000001), (-0.99999999999999999999999999999999999998, -0.00000000000000000000000000000000000001);
+SELECT "add_test_38_38_38_38", d1 + d2 FROM cs9;
+INSERT INTO cs10 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs10 VALUES (0.1234567890123456789, 0.1234567890123456789), (0.1234567890123456789, -0.2234567890123456789);
+INSERT INTO cs10 VALUES (0.9999999999999999998, 0.0000000000000000001), (-0.9999999999999999998, -0.0000000000000000001);
+SELECT "add_test_19_19_19_19", d1 + d2 FROM cs10;
+INSERT INTO cs11 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs11 VALUES (0.12345678901234567890123456789012345678, 0.1234567890123456789), (0.12345678901234567890123456789012345678, -0.2234567890123456789);
+INSERT INTO cs11 VALUES (0.99999999999999999999999999999999999998, 0.0000000000000000001), (-0.99999999999999999999999999999999999998, -0.0000000000000000001);
+SELECT "add_test_38_38_19_19", d1 + d2 FROM cs11;
+INSERT INTO cs12 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs12 VALUES (0.12345678901234567890123456789012345678, 0.1234567890), (0.12345678901234567890123456789012345678, -0.2234567890);
+INSERT INTO cs12 VALUES (0.99999999999999999999999999999999999998, 0.0000000001), (-0.99999999999999999999999999999999999998, -0.0000000001);
+SELECT "add_test_38_38_10_10", d1 + d2 FROM cs12;
+
+# with overflow check
+# SET columnstore_decimal_overflow_check=on;
+# CALL deleteproc();
+# INSERT INTO cs1 VALUES (99999999999999999999999999999999999999, 99999999999999999999999999999999999999), (-99999999999999999999999999999999999999, -99999999999999999999999999999999999999);
+# SELECT "add_test_38_0_38_0_overflow", d1 + d2 FROM cs1;
+# INSERT INTO cs9 VALUES (0.99999999999999999999999999999999999999, 0.99999999999999999999999999999999999999), (-0.99999999999999999999999999999999999999, -0.99999999999999999999999999999999999999);
+# SELECT "add_test_38_38_38_38_overflow", d1 + d2 FROM cs9;
+
+# Subtraction
+# without overflow check
+SET columnstore_decimal_overflow_check=off;
+CALL deleteproc();
+INSERT INTO cs1 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs1 VALUES (12345678901234567890123456789012345678, -12345678901234567890123456789012345678), (-12345678901234567890123456789012345678, -22345678901234567890123456789012345678);
+INSERT INTO cs1 VALUES (99999999999999999999999999999999999999, 1), (-99999999999999999999999999999999999999, -1);
+SELECT "subtract_test_38_0_38_0", d1 - d2 FROM cs1;
+INSERT INTO cs2 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs2 VALUES (1234567890123456789, -1234567890123456789), (-1234567890123456789, -2234567890123456789);
+INSERT INTO cs2 VALUES (9999999999999999999, 1), (-9999999999999999999, -1);
+SELECT "subtract_test_19_0_19_0", d1 - d2 FROM cs2;
+INSERT INTO cs3 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs3 VALUES (12345678901234567890123456789012345678, 1234567890123456789), (-12345678901234567890123456789012345678, -2234567890123456789);
+INSERT INTO cs3 VALUES (99999999999999999999999999999999999999, 1), (-99999999999999999999999999999999999999, -1);
+SELECT "subtract_test_38_0_19_0", d1 - d2 FROM cs3;
+INSERT INTO cs4 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs4 VALUES (12345678901234567890123456789012345678, 1234567890), (-12345678901234567890123456789012345678, -2234567890);
+INSERT INTO cs4 VALUES (99999999999999999999999999999999999999, 1), (-99999999999999999999999999999999999999, -1);
+SELECT "subtract_test_38_0_10_0", d1 - d2 FROM cs4;
+INSERT INTO cs5 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs5 VALUES (1234567890123456789012345678.9012345678, -1234567890123456789012345678.9012345678), (-1234567890123456789012345678.9012345678, -2234567890123456789012345678.9012345678);
+INSERT INTO cs5 VALUES (9999999999999999999999999999.9999999999, 0.0000000001), (-9999999999999999999999999999.9999999999, -0.0000000001);
+SELECT "subtract_test_38_10_38_10", d1 - d2 FROM cs5;
+INSERT INTO cs6 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs6 VALUES (123456789.0123456789, -123456789.0123456789), (-123456789.0123456789, -223456789.0123456789);
+INSERT INTO cs6 VALUES (999999999.9999999998, 0.0000000001), (-999999999.9999999998, -0.0000000001);
+SELECT "subtract_test_19_10_19_10", d1 - d2 FROM cs6;
+INSERT INTO cs7 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs7 VALUES (1234567890123456789012345678.9012345678, 123456789.0123456789), (-1234567890123456789012345678.9012345678, -223456789.0123456789);
+INSERT INTO cs7 VALUES (9999999999999999999999999999.9999999998, 0.0000000001), (-9999999999999999999999999999.9999999998, -0.0000000001);
+SELECT "subtract_test_38_10_19_10", d1 - d2 FROM cs7;
+INSERT INTO cs8 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs8 VALUES (1234567890123456789012345678.9012345678, 0.1234567890), (-1234567890123456789012345678.9012345678, -0.2234567890);
+INSERT INTO cs8 VALUES (9999999999999999999999999999.9999999998, 0.0000000001), (-9999999999999999999999999999.9999999998, -0.0000000001);
+SELECT "subtract_test_38_10_10_10", d1 - d2 FROM cs8;
+INSERT INTO cs9 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs9 VALUES (-0.12345678901234567890123456789012345678, 0.12345678901234567890123456789012345678), (-0.12345678901234567890123456789012345678, -0.22345678901234567890123456789012345678);
+INSERT INTO cs9 VALUES (0.99999999999999999999999999999999999998, 0.00000000000000000000000000000000000001), (-0.99999999999999999999999999999999999998, -0.00000000000000000000000000000000000001);
+SELECT "subtract_test_38_38_38_38", d1 - d2 FROM cs9;
+INSERT INTO cs10 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs10 VALUES (0.1234567890123456789, 0.1234567890123456788), (0.1234567890123456789, -0.2234567890123456789);
+INSERT INTO cs10 VALUES (0.9999999999999999998, 0.0000000100000000001), (-0.9999999999999999998, -0.0000000100000000001);
+SELECT "subtract_test_19_19_19_19", d1 - d2 FROM cs10;
+INSERT INTO cs11 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs11 VALUES (0.12345678901234567890123456789012345678, 0.1234567890123456789), (-0.12345678901234567890123456789012345678, -0.2234567890123456789);
+INSERT INTO cs11 VALUES (0.99999999999999999999999999999999999998, 0.0000000000000000001), (-0.99999999999999999999999999999999999998, -0.0000000000000000001);
+SELECT "subtract_test_38_38_19_19", d1 - d2 FROM cs11;
+INSERT INTO cs12 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs12 VALUES (0.12345678901234567890123456789012345678, 0.1234567890), (0.12345678901234567890123456789012345678, -0.2234567890);
+INSERT INTO cs12 VALUES (0.99999999999999999999999999999999999998, 0.0000000001), (-0.99999999999999999999999999999999999998, -0.0000000001);
+SELECT "subtract_test_38_38_10_10", d1 - d2 FROM cs12;
+
+# with overflow check
+# SET columnstore_decimal_overflow_check=on;
+# CALL deleteproc();
+# INSERT INTO cs1 VALUES (99999999999999999999999999999999999999, -99999999999999999999999999999999999999), (99999999999999999999999999999999999999, -99999999999999999999999999999999999999);
+# SELECT "subtract_test_38_0_38_0_overflow", d1 - d2 FROM cs1;
+# INSERT INTO cs9 VALUES (0.99999999999999999999999999999999999999, -0.99999999999999999999999999999999999999), (0.99999999999999999999999999999999999999, -0.99999999999999999999999999999999999999);
+# SELECT "subtract_test_38_38_38_38_overflow", d1 - d2 FROM cs9;
+
+# Multiplication
+# without overflow check
+SET columnstore_decimal_overflow_check=off;
+CALL deleteproc();
+INSERT INTO cs1 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs1 VALUES (1234567890123456789, 1234567890123456789), (1234567890123456789, -2234567890123456789);
+INSERT INTO cs1 VALUES (9999999999999999999999999999, 10000000000), (-9999999999999999999999999999, -10000000000);
+SELECT "multiply_test_38_0_38_0", d1 * d2 FROM cs1;
+INSERT INTO cs2 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs2 VALUES (1234567890123456789, 1234567890123456789), (1234567890123456789, -2234567890123456789);
+INSERT INTO cs2 VALUES (9999999999999999998, 1), (-9999999999999999998, -1);
+SELECT "multiply_test_19_0_19_0", d1 * d2 FROM cs2;
+INSERT INTO cs3 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs3 VALUES (1234567890123456789, 1234567890123456789), (1234567890123456789, -2234567890123456789);
+INSERT INTO cs3 VALUES (99999999999999999999999999999999999998, 1), (-99999999999999999999999999999999999998, -1);
+SELECT "multiply_test_38_0_19_0", d1 * d2 FROM cs3;
+INSERT INTO cs4 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs4 VALUES (1234567890123456789012345678, 1234567890), (1234567890123456789012345678, -2234567890);
+INSERT INTO cs4 VALUES (99999999999999999999999999998, 1000000000), (-99999999999999999999999999998, -1000000000);
+SELECT "multiply_test_38_0_10_0", d1 * d2 FROM cs4;
+INSERT INTO cs5 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs5 VALUES (123456789.0123456789, 123456789.0123456789), (123456789.0123456789, -223456789.0123456789);
+INSERT INTO cs5 VALUES (999999999.9999999998, 0.0000000001), (-999999999.9999999998, -0.0000000001);
+SELECT "multiply_test_38_10_38_10", d1 * d2 FROM cs5;
+INSERT INTO cs6 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs6 VALUES (123456789.0123456789, 123456789.0123456789), (123456789.0123456789, -223456789.0123456789);
+INSERT INTO cs6 VALUES (999999999.9999999998, 0.0000000001), (-999999999.9999999998, -0.0000000001);
+SELECT "multiply_test_19_10_19_10", d1 * d2 FROM cs6;
+INSERT INTO cs7 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs7 VALUES (123456789.0123456789, 123456789.0123456789), (123456789.0123456789, -223456789.0123456789);
+INSERT INTO cs7 VALUES (999999999.9999999998, 0.0000000001), (-999999999.9999999998, -0.0000000001);
+SELECT "multiply_test_38_10_19_10", d1 * d2 FROM cs7;
+INSERT INTO cs8 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs8 VALUES (123456789012345678.9012345678, 0.1234567890), (123456789012345678.9012345678, -0.2234567890);
+INSERT INTO cs8 VALUES (999999999999999999.9999999998, 0.0000000001), (-999999999999999999.9999999998, -0.0000000001);
+SELECT "multiply_test_38_10_10_10", d1 * d2 FROM cs8;
+INSERT INTO cs9 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs9 VALUES (0.1234567890123456789, 0.1234567890123456789), (0.1234567890123456789, -0.2234567890123456789);
+INSERT INTO cs9 VALUES (0.9999999999999999998, 0.0000000000000000001), (-0.9999999999999999998, -0.0000000000000000001);
+SELECT "multiply_test_38_38_38_38", d1 * d2 FROM cs9;
+INSERT INTO cs10 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs10 VALUES (0.1234567890123456789, 0.1234567890123456789), (0.1234567890123456789, -0.2234567890123456789);
+INSERT INTO cs10 VALUES (0.9999999999999999998, 0.0000000000000000001), (-0.9999999999999999998, -0.0000000000000000001);
+SELECT "multiply_test_19_19_19_19", d1 * d2 FROM cs10;
+INSERT INTO cs11 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs11 VALUES (0.1234567890123456789, 0.123456789), (0.1234567890123456789, -0.223456789);
+INSERT INTO cs11 VALUES (0.9999999999999999998, 0.000000001), (-0.9999999999999999998, -0.000000001);
+SELECT "multiply_test_38_38_19_19", d1 * d2 FROM cs11;
+INSERT INTO cs12 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs12 VALUES (0.1234567890123456789012345678, 0.12345), (0.1234567890123456789012345678, -0.22345);
+INSERT INTO cs12 VALUES (0.9999999999999999999999999998, 0.00001), (-0.9999999999999999999999999998, -0.00001);
+SELECT "multiply_test_38_38_10_10", d1 * d2 FROM cs12;
+
+# with overflow check
+# SET columnstore_decimal_overflow_check=on;
+# CALL deleteproc();
+# INSERT INTO cs1 VALUES (99999999999999999999999999999999999999, 99999999999999999999999999999999999999), (-99999999999999999999999999999999999999, -99999999999999999999999999999999999999);
+# INSERT INTO cs1 VALUES (12345678901234567890123456789012345678, 12345678901234567890123456789012345678), (12345678901234567890123456789012345678, -22345678901234567890123456789012345678);
+# SELECT "multiply_test_38_0_38_0_overflow", d1 * d2 FROM cs1;
+# INSERT INTO cs3 VALUES (12345678901234567890123456789012345678, 1234567890123456789), (12345678901234567890123456789012345678, -2234567890123456789);
+# SELECT "multiply_test_38_0_19_0", d1 * d2 FROM cs3;
+# INSERT INTO cs4 VALUES (12345678901234567890123456789012345678, 1234567890), (12345678901234567890123456789012345678, -2234567890);
+# SELECT "multiply_test_38_0_10_0", d1 * d2 FROM cs4;
+# INSERT INTO cs5 VALUES (1234567890123456789012345678.9012345678, 1234567890123456789012345678.9012345678), (1234567890123456789012345678.9012345678, -2234567890123456789012345678.9012345678);
+# SELECT "multiply_test_38_10_38_10", d1 * d2 FROM cs5;
+# INSERT INTO cs7 VALUES (1234567890123456789012345678.9012345678, 123456789.0123456789), (1234567890123456789012345678.9012345678, -223456789.0123456789);
+# SELECT "multiply_test_38_10_19_10", d1 * d2 FROM cs7;
+# INSERT INTO cs8 VALUES (1234567890123456789012345678.9012345678, 0.1234567890), (1234567890123456789012345678.9012345678, -0.2234567890);
+# SELECT "multiply_test_38_10_10_10", d1 * d2 FROM cs8;
+# INSERT INTO cs9 VALUES (0.12345678901234567890123456789012345678, 0.12345678901234567890123456789012345678), (0.12345678901234567890123456789012345678, -0.22345678901234567890123456789012345678);
+# SELECT "multiply_test_38_38_38_38_overflow", d1 * d2 FROM cs9;
+# INSERT INTO cs11 VALUES (0.12345678901234567890123456789012345678, 0.1234567890123456789), (0.12345678901234567890123456789012345678, -0.2234567890123456789);
+# SELECT "multiply_test_38_38_19_19", d1 * d2 FROM cs11;
+# INSERT INTO cs12 VALUES (0.12345678901234567890123456789012345678, 0.1234567890), (0.12345678901234567890123456789012345678, -0.2234567890);
+# SELECT "multiply_test_38_38_10_10", d1 * d2 FROM cs12;
+
+# Division
+# without overflow check
+SET columnstore_decimal_overflow_check=off;
+CALL deleteproc();
+INSERT INTO cs1 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs1 VALUES (12345678901234567890123456789012345678, 4567890123456789), (12345678901234567890123456789012345678, -223456789012345678901234567890123456);
+INSERT INTO cs1 VALUES (44444444444444444444444444444444444444, 10000000000), (-44444444444444444444444444444444, 1000);
+SELECT "divide_test_38_0_38_0", d1 / d2, d2 / d1 FROM cs1;
+INSERT INTO cs2 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs2 VALUES (1234567890123456789, 4567890123456789), (1234567890123456789, -223456789012345678);
+INSERT INTO cs2 VALUES (4444444444444444444, 10000000000), (-44444444444444444, -1000);
+SELECT "divide_test_19_0_19_0", d1 / d2, d2 / d1 FROM cs2;
+INSERT INTO cs3 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs3 VALUES (12345678901234567890123456789012345678, 4567890123456789), (12345678901234567890123456789012345678, -2234567890123456);
+INSERT INTO cs3 VALUES (4444444444444444444, 10000000000), (-44444444444444444, -1000);
+SELECT "divide_test_38_0_19_0", d1 / d2, d2 / d1 FROM cs3;
+INSERT INTO cs4 VALUES (1234, 5678), (1234, -5678);
+INSERT INTO cs4 VALUES (12345678901234567890123456789012345678, 4567890123), (12345678901234567890123456789012345678, -2234567890);
+INSERT INTO cs4 VALUES (4444444444444444444, 1000000000), (-44444444444444444, -1000);
+SELECT "divide_test_38_0_10_0", d1 / d2, d2 / d1 FROM cs4;
+INSERT INTO cs5 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs5 VALUES (1234567890123456789012345678.9012345678, 4567890123456789.0123456789), (1234567890123456789012345678.9012345678, -22345678901234567890123456.7890123456);
+INSERT INTO cs5 VALUES (4444444444444444444444444444.4444444444, 10000000000.0), (-4444444444444444444444.4444444444, 1000.0);
+SELECT "divide_test_38_10_38_10", d1 / d2, d2 / d1 FROM cs5;
+INSERT INTO cs6 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs6 VALUES (123456789.0123456789, 456789.0123456789), (123456789.0123456789, -22345678.9012345678);
+INSERT INTO cs6 VALUES (444444444.4444444444, 100000000.0), (-4444444.4444444444, -1000.0);
+SELECT "divide_test_19_10_19_10", d1 / d2, d2 / d1 FROM cs6;
+INSERT INTO cs7 VALUES (12.34, 56.78), (12.34, -56.78);
+INSERT INTO cs7 VALUES (1234567890123456789012345678.9012345678, 456789012.0123456789), (1234567890123456789012345678.9012345678, -223456789.7890123456);
+INSERT INTO cs7 VALUES (444444444.4444444444, 100000000.0), (-4444444.4444444444, -1000.0);
+SELECT "divide_test_38_10_19_10", d1 / d2, d2 / d1 FROM cs7;
+INSERT INTO cs8 VALUES (12.34, 0.5678), (12.34, -0.5678);
+INSERT INTO cs8 VALUES (1234567890123456789.9012345678, 0.4567890123), (1234567890123456789.9012345678, -0.2234567890);
+INSERT INTO cs8 VALUES (444444444.4444444444, 0.10000000), (-4444444.4444444444, -0.10000);
+SELECT "divide_test_38_10_10_10", d1 / d2, d2 / d1 FROM cs8;
+INSERT INTO cs9 VALUES (0.0000000000000000000000000001234, 0.000000000000000000005678), (0.000000000000000000000000001234, -0.000000000000000000005678);
+INSERT INTO cs9 VALUES (0.00000000000000000004567890123456789, 0.12345678901234567890123456789012345678), (-0.000000000000000002234567890123456789, 0.12345678901234567890123456789012345678);
+INSERT INTO cs9 VALUES (0.000000000000010000000000, 0.44444444444444444444444444444444444444), (0.00000000000001000, -0.44444444444444444444444444444444);
+# d2 / d1 will result in an overflow
+SELECT "divide_test_38_38_38_38", d1 / d2 FROM cs9;
+INSERT INTO cs10 VALUES (0.1234, 0.5678), (0.1234, -0.5678);
+INSERT INTO cs10 VALUES (0.1234567890123456789, 0.4567890123456789), (0.1234567890123456789, -0.223456789012345678);
+INSERT INTO cs10 VALUES (0.4444444444444444444, 0.10000000000), (-0.44444444444444444, -0.1000);
+SELECT "divide_test_19_19_19_19", d1 / d2, d2 / d1 FROM cs10;
+# we lose a few decimal places in the end in the following test,
+# so commenting out for now
+# INSERT INTO cs11 VALUES (0.00000000000000000000001234, 0.0000000000000005678), (0.0000000000000000000001234, -0.0000000000000005678);
+# INSERT INTO cs11 VALUES (0.000000000000004567890123456789, 0.1234567890123456789), (-0.0000000000002234567890123456789, 0.1234567890123456789);
+# INSERT INTO cs11 VALUES (0.0000000010000000000, 0.44444444444444444444), (0.000000001000, -0.4444444444444444444);
+# SELECT "divide_test_38_38_19_19", d1 / d2, d2 / d1 FROM cs11;
+INSERT INTO cs12 VALUES (0.0000000000000000000000000000001234, 0.5678), (0.0000000000000000000000000000001234, -0.5678);
+INSERT INTO cs12 VALUES (0.00000000001234567890123456789012345678, 0.4567890123), (0.00000000001234567890123456789012345678, -0.2234567890);
+INSERT INTO cs12 VALUES (0.000000000000000000004444444444444444444, 0.1000000000), (-0.0000000000000000000044444444444444444, -0.1000);
+# d2 / d1 will result in an overflow
+SELECT "divide_test_38_38_10_10", d1 / d2 FROM cs12;
+
+
+# with overflow check
+# we cannot trigger the division overflow of lhs == Decimal::minInt128 && rhs == -1
+# since lhs = -170141183460469231731687303715884105728 cannot be inserted
+# into a decimal(38) column
+
+# Clean UP
+DROP PROCEDURE IF EXISTS deleteproc;
+DROP DATABASE mcol641_arithmetic_db;
--- a/mysql-test/columnstore/basic/t/mcol641-create.test
+++ b/mysql-test/columnstore/basic/t/mcol641-create.test
@ -0,0 +1,54 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS test_mcol641_create;
+--enable_warnings
+
+CREATE DATABASE test_mcol641_create;
+USE test_mcol641_create;
+
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+DROP TABLE IF EXISTS cs2;
+DROP TABLE IF EXISTS cs3;
+DROP TABLE IF EXISTS cs4;
+--enable_warnings
+
+CREATE TABLE cs1(d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38), d4 DECIMAL(19), d5 DECIMAL(19,19),d6 DECIMAL(19,10)) ENGINE=columnstore;
+CREATE TABLE cs2(d1 DECIMAL(38) SIGNED, d2 DECIMAL(38,10) SIGNED, d3 DECIMAL(38,38) SIGNED) ENGINE=columnstore; 
+#This must raise a warning
+CREATE TABLE cs3(d1 DECIMAL(38) UNSIGNED ZEROFILL, d2 DECIMAL(38,10) UNSIGNED ZEROFILL, d3 DECIMAL(38,38) UNSIGNED ZEROFILL) ENGINE=columnstore; 
+CREATE TABLE cs4(d1 DECIMAL(18), d2 DECIMAL(18,10), d3 DECIMAL(18,18)) ENGINE=columnstore;
+SELECT TABLE_SCHEMA,TABLE_NAME,COLUMN_NAME,DATA_TYPE,COLUMN_LENGTH,COLUMN_POSITION,COLUMN_DEFAULT,NUMERIC_PRECISION,NUMERIC_SCALE FROM information_schema.columnstore_columns WHERE table_name = 'cs1' OR table_name = 'cs2' OR table_name = 'cs3' OR table_name = 'cs4' ORDER BY table_name,column_name ASC;
+
+ALTER TABLE cs1 DROP COLUMN d4;
+ALTER TABLE cs1 ADD COLUMN d7 DECIMAL(38,37);
+ALTER TABLE cs2 ADD COLUMN d4 DECIMAL(30,30) SIGNED;
+ALTER TABLE cs3 ADD COLUMN d5 DECIMAL(20,18) UNSIGNED;
+# Bug. This must work fine.
+--error 1178
+ALTER TABLE cs1 RENAME COLUMN d7 TO d17;
+# Bug. This must work fine.
+--error 1178
+ALTER TABLE cs2 ADD COLUMN (d5 DECIMAL(38,5), d6 DECIMAL(35,15));
+# Bug. This must work fine.
+--error 1815
+ALTER TABLE cs3 MODIFY d1 DECIMAL(38) SIGNED;
+SELECT TABLE_SCHEMA,TABLE_NAME,COLUMN_NAME,DATA_TYPE,COLUMN_LENGTH,COLUMN_POSITION,COLUMN_DEFAULT,NUMERIC_PRECISION,NUMERIC_SCALE FROM information_schema.columnstore_columns WHERE table_schema = 'test_mcol641_create' ORDER BY table_name,column_name ASC;
+
+# This must return an error
+--error 1815
+CREATE TABLE cs5(d1 DECIMAL(39)) ENGINE=columnstore;
+--error 1425
+CREATE TABLE cs5(d1 DECIMAL(38,39)) ENGINE=columnstore;
+--error 1815
+ALTER TABLE cs1 ADD COLUMN d10 DECIMAL(40);
+--error 1425
+ALTER TABLE cs1 ADD COLUMN d11 DECIMAL(38,40);
+
+DROP TABLE cs1;
+DROP TABLE cs2;
+DROP TABLE cs3;
+DROP TABLE cs4;
+
+DROP DATABASE test_mcol641_create;
--- a/mysql-test/columnstore/basic/t/mcol641-delete.test
+++ b/mysql-test/columnstore/basic/t/mcol641-delete.test
@ -0,0 +1,331 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS mcol641_delete_db;
+--enable_warnings
+
+CREATE DATABASE mcol641_delete_db;
+USE mcol641_delete_db;
+
+DROP PROCEDURE IF EXISTS signedinsertproc;
+DROP PROCEDURE IF EXISTS signeddeleteproc;
+DROP PROCEDURE IF EXISTS unsignedinsertproc;
+DROP PROCEDURE IF EXISTS unsigneddeleteproc;
+
+DELIMITER //;
+
+CREATE PROCEDURE signedinsertproc ()
+ BEGIN
+  INSERT INTO cs1 VALUES (125, 125);
+  INSERT INTO cs1 VALUES (-125, -125);
+  INSERT INTO cs1 values (99999999999999999999999999999999999998, 9999999999999999998);
+  INSERT INTO cs1 values (99999999999999999999999999999999999999, 9999999999999999999);
+  INSERT INTO cs1 values (-99999999999999999999999999999999999998, -9999999999999999998);
+  INSERT INTO cs1 values (-99999999999999999999999999999999999999, -9999999999999999999);
+  INSERT INTO cs1 VALUES (0, 0);
+  INSERT INTO cs1 VALUES (NULL, NULL);
+  
+  INSERT INTO cs2 VALUES (1.25, 1.25);
+  INSERT INTO cs2 VALUES (-1.25, -1.25);
+  INSERT INTO cs2 values (9999999999999999999999999999.9999999998, 999999999.9999999998);
+  INSERT INTO cs2 values (9999999999999999999999999999.9999999999, 999999999.9999999999);
+  INSERT INTO cs2 values (-9999999999999999999999999999.9999999998, -999999999.9999999998);
+  INSERT INTO cs2 values (-9999999999999999999999999999.9999999999, -999999999.9999999999);
+  INSERT INTO cs2 VALUES (1.1234567891, 1.1234567891);
+  INSERT INTO cs2 VALUES (1.9999999999, 1.9999999999);
+  INSERT INTO cs2 VALUES (-1.1234567891, -1.1234567891);
+  INSERT INTO cs2 VALUES (-1.9999999999, -1.9999999999);
+  INSERT INTO cs2 VALUES (1.0000000009, 1.0000000009);
+  INSERT INTO cs2 VALUES (-1.0000000009, -1.0000000009);
+  INSERT INTO cs2 VALUES (0, 0);
+  INSERT INTO cs2 VALUES (NULL, NULL);
+  
+  INSERT INTO cs3 VALUES (0.125, 0.125);
+  INSERT INTO cs3 VALUES (-0.125, -0.125);
+  INSERT INTO cs3 values (0.99999999999999999999999999999999999998, 0.9999999999999999998);
+  INSERT INTO cs3 values (0.99999999999999999999999999999999999999, 0.9999999999999999999);
+  INSERT INTO cs3 values (-0.99999999999999999999999999999999999998, -0.9999999999999999998);
+  INSERT INTO cs3 values (-0.99999999999999999999999999999999999999, -0.9999999999999999999);
+  INSERT INTO cs3 VALUES (0.12345678901234567890123456789012345678, 0.1234567890123456789);
+  INSERT INTO cs3 VALUES (0.19999999999999999999999999999999999999, 0.1999999999999999999);
+  INSERT INTO cs3 VALUES (-0.12345678901234567890123456789012345678, -0.1234567890123456789);
+  INSERT INTO cs3 VALUES (-0.19999999999999999999999999999999999999, -0.1999999999999999999);
+  INSERT INTO cs3 VALUES (0.00000000000000000000000000000000000009, 0.0000000000000000009);
+  INSERT INTO cs3 VALUES (-0.00000000000000000000000000000000000009, -0.0000000000000000009);
+  INSERT INTO cs3 VALUES (0, 0);
+  INSERT INTO cs3 VALUES (NULL, NULL);
+ END//
+
+CREATE PROCEDURE unsignedinsertproc ()
+ BEGIN
+  INSERT INTO cs4 VALUES (125, 125);
+  INSERT INTO cs4 values (99999999999999999999999999999999999998, 9999999999999999998);
+  INSERT INTO cs4 values (99999999999999999999999999999999999999, 9999999999999999999);
+  INSERT INTO cs4 VALUES (0, 0);
+  INSERT INTO cs4 VALUES (NULL, NULL);
+
+  INSERT INTO cs5 VALUES (1.25, 1.25);
+  INSERT INTO cs5 values (9999999999999999999999999999.9999999998, 999999999.9999999998);
+  INSERT INTO cs5 values (9999999999999999999999999999.9999999999, 999999999.9999999999);
+  INSERT INTO cs5 VALUES (1.1234567891, 1.1234567891);
+  INSERT INTO cs5 VALUES (1.9999999999, 1.9999999999);
+  INSERT INTO cs5 VALUES (1.0000000009, 1.0000000009);
+  INSERT INTO cs5 VALUES (0, 0);
+  INSERT INTO cs5 VALUES (NULL, NULL);
+
+  INSERT INTO cs6 VALUES (0.125, 0.125);
+  INSERT INTO cs6 values (0.99999999999999999999999999999999999998, 0.9999999999999999998);
+  INSERT INTO cs6 values (0.99999999999999999999999999999999999999, 0.9999999999999999999);
+  INSERT INTO cs6 VALUES (0.12345678901234567890123456789012345678, 0.1234567890123456789);
+  INSERT INTO cs6 VALUES (0.19999999999999999999999999999999999999, 0.1999999999999999999);
+  INSERT INTO cs6 VALUES (0.00000000000000000000000000000000000009, 0.0000000000000000009);
+  INSERT INTO cs6 VALUES (0, 0);
+  INSERT INTO cs6 VALUES (NULL, NULL);
+ END//
+
+CREATE PROCEDURE signeddeleteproc ()
+ BEGIN
+  DELETE FROM cs1;
+  DELETE FROM cs2;
+  DELETE FROM cs3;
+ END//
+
+CREATE PROCEDURE unsigneddeleteproc ()
+ BEGIN
+  DELETE FROM cs4;
+  DELETE FROM cs5;
+  DELETE FROM cs6;
+ END//
+
+DELIMITER ;//
+
+DROP TABLE IF EXISTS cs1;
+DROP TABLE IF EXISTS cs2;
+DROP TABLE IF EXISTS cs3;
+DROP TABLE IF EXISTS cs4;
+DROP TABLE IF EXISTS cs5;
+DROP TABLE IF EXISTS cs6;
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(19)) ENGINE=columnstore;
+CREATE TABLE cs2 (d1 DECIMAL(38,10), d2 DECIMAL(19,10)) ENGINE=columnstore;
+CREATE TABLE cs3 (d1 DECIMAL(38,38), d2 DECIMAL(19,19)) ENGINE=columnstore;
+CREATE TABLE cs4 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(19) UNSIGNED) ENGINE=columnstore;
+CREATE TABLE cs5 (d1 DECIMAL(38,10) UNSIGNED, d2 DECIMAL(19,10) UNSIGNED) ENGINE=columnstore;
+CREATE TABLE cs6 (d1 DECIMAL(38,38) UNSIGNED, d2 DECIMAL(19,19) UNSIGNED) ENGINE=columnstore;
+
+CALL signedinsertproc();
+
+# Full table delete
+DELETE FROM cs1;
+DELETE FROM cs2;
+DELETE FROM cs3;
+SELECT "signedtest1", d1, d2 FROM cs1;
+SELECT "signedtest1", d1, d2 FROM cs2;
+SELECT "signedtest1", d1, d2 FROM cs3;
+
+# Deletes with WHERE clause
+# Delete a single row with a constant value in WHERE clause
+CALL signedinsertproc();
+DELETE FROM cs1 WHERE d1=-99999999999999999999999999999999999998;
+DELETE FROM cs1 WHERE d2=9999999999999999999;
+DELETE FROM cs2 WHERE d1=-9999999999999999999999999999.9999999998;
+DELETE FROM cs2 WHERE d2=999999999.9999999999;
+DELETE FROM cs3 WHERE d1=-0.99999999999999999999999999999999999998;
+DELETE FROM cs3 WHERE d2=0.9999999999999999999;
+SELECT "signedtest2", d1, d2 FROM cs1;
+SELECT "signedtest2", d1, d2 FROM cs2;
+SELECT "signedtest2", d1, d2 FROM cs3;
+
+# Delete multiple rows
+# Deletes with multiple constant values in WHERE clause
+CALL signeddeleteproc();
+CALL signedinsertproc();
+DELETE FROM cs1 WHERE d1 in (-99999999999999999999999999999999999998, 99999999999999999999999999999999999999);
+DELETE FROM cs2 WHERE d1 in (-9999999999999999999999999999.9999999998, 9999999999999999999999999999.9999999999);
+DELETE FROM cs3 WHERE d1 in (-0.99999999999999999999999999999999999998, 0.99999999999999999999999999999999999999);
+SELECT "signedtest3", d1, d2 FROM cs1;
+SELECT "signedtest3", d1, d2 FROM cs2;
+SELECT "signedtest3", d1, d2 FROM cs3;
+
+# Deletes with comparison operators in WHERE clause
+CALL signeddeleteproc();
+CALL signedinsertproc();
+DELETE FROM cs1 WHERE d1 <= -99999999999999999999999999999999999998 OR d2 >= 9999999999999999998;
+DELETE FROM cs2 WHERE d1 <= -9999999999999999999999999999.9999999998 OR d2 >= 999999999.9999999998;
+DELETE FROM cs3 WHERE d1 <= -0.99999999999999999999999999999999999998 OR d2 >= 0.9999999999999999998;
+SELECT "signedtest4a", d1, d2 FROM cs1;
+SELECT "signedtest4a", d1, d2 FROM cs2;
+SELECT "signedtest4a", d1, d2 FROM cs3;
+CALL signeddeleteproc();
+CALL signedinsertproc();
+DELETE FROM cs1 WHERE d1 < -99999999999999999999999999999999999998 OR d2 > 9999999999999999998;
+DELETE FROM cs2 WHERE d1 < -9999999999999999999999999999.9999999998 OR d2 > 999999999.9999999998;
+DELETE FROM cs3 WHERE d1 < -0.99999999999999999999999999999999999998 OR d2 > 0.9999999999999999998;
+SELECT "signedtest4", d1, d2 FROM cs1;
+SELECT "signedtest4", d1, d2 FROM cs2;
+SELECT "signedtest4", d1, d2 FROM cs3;
+
+# Delete with NULL in the WHERE clause
+DELETE FROM cs1 WHERE d1 is NULL;
+DELETE FROM cs2 WHERE d1 is NULL;
+DELETE FROM cs3 WHERE d1 is NULL;
+SELECT "signedtest5", d1, d2 FROM cs1;
+SELECT "signedtest5", d1, d2 FROM cs2;
+SELECT "signedtest5", d1, d2 FROM cs3;
+
+# Delete with != operator
+DELETE FROM cs1 WHERE d1 != 125;
+DELETE FROM cs2 WHERE d1 != 1.25;
+DELETE FROM cs3 WHERE d1 != 0.125;
+SELECT "signedtest6", d1, d2 FROM cs1;
+SELECT "signedtest6", d1, d2 FROM cs2;
+SELECT "signedtest6", d1, d2 FROM cs3;
+
+# Delete with non-constant value in the WHERE clause
+CALL signeddeleteproc();
+CALL signedinsertproc();
+DELETE FROM cs1 WHERE d1 = d2;
+DELETE FROM cs2 WHERE d1 = d2;
+DELETE FROM cs3 WHERE d1 = d2;
+SELECT "signedtest7", d1, d2 FROM cs1;
+SELECT "signedtest7", d1, d2 FROM cs2;
+SELECT "signedtest7", d1, d2 FROM cs3;
+CALL signeddeleteproc();
+CALL signedinsertproc();
+DELETE FROM cs1 WHERE d1 != d2;
+DELETE FROM cs2 WHERE d1 != d2;
+DELETE FROM cs3 WHERE d1 != d2;
+SELECT "signedtest8", d1, d2 FROM cs1;
+SELECT "signedtest8", d1, d2 FROM cs2;
+SELECT "signedtest8", d1, d2 FROM cs3;
+CALL signeddeleteproc();
+CALL signedinsertproc();
+DELETE FROM cs1 WHERE d1 < d2;
+DELETE FROM cs2 WHERE d1 < d2;
+DELETE FROM cs3 WHERE d1 < d2;
+SELECT "signedtest9", d1, d2 FROM cs1;
+SELECT "signedtest9", d1, d2 FROM cs2;
+SELECT "signedtest9", d1, d2 FROM cs3;
+CALL signeddeleteproc();
+CALL signedinsertproc();
+DELETE FROM cs1 WHERE d1 > d2;
+DELETE FROM cs2 WHERE d1 > d2;
+DELETE FROM cs3 WHERE d1 > d2;
+SELECT "signedtest10", d1, d2 FROM cs1;
+SELECT "signedtest10", d1, d2 FROM cs2;
+SELECT "signedtest10", d1, d2 FROM cs3;
+
+# Deletes with functions and expressions in the WHERE clause
+
+
+# Repeat above tests for the unsigned case
+CALL unsignedinsertproc();
+
+# Full table delete
+DELETE FROM cs4;
+DELETE FROM cs5;
+DELETE FROM cs6;
+SELECT "unsignedtest1", d1, d2 FROM cs4;
+SELECT "unsignedtest1", d1, d2 FROM cs5;
+SELECT "unsignedtest1", d1, d2 FROM cs6;
+
+# Deletes with WHERE clause
+# Delete a single row with a constant value in WHERE clause
+CALL unsignedinsertproc();
+DELETE FROM cs4 WHERE d1=99999999999999999999999999999999999998;
+DELETE FROM cs4 WHERE d2=9999999999999999999;
+DELETE FROM cs5 WHERE d1=9999999999999999999999999999.9999999998;
+DELETE FROM cs5 WHERE d2=999999999.9999999999;
+DELETE FROM cs6 WHERE d1=0.99999999999999999999999999999999999998;
+DELETE FROM cs6 WHERE d2=0.9999999999999999999;
+SELECT "unsignedtest2", d1, d2 FROM cs4;
+SELECT "unsignedtest2", d1, d2 FROM cs5;
+SELECT "unsignedtest2", d1, d2 FROM cs6;
+
+# Delete multiple rows
+# Deletes with multiple constant values in WHERE clause
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+DELETE FROM cs4 WHERE d1 in (99999999999999999999999999999999999998, 99999999999999999999999999999999999999);
+DELETE FROM cs5 WHERE d1 in (9999999999999999999999999999.9999999998, 9999999999999999999999999999.9999999999);
+DELETE FROM cs6 WHERE d1 in (0.99999999999999999999999999999999999998, 0.99999999999999999999999999999999999999);
+SELECT "unsignedtest3", d1, d2 FROM cs4;
+SELECT "unsignedtest3", d1, d2 FROM cs5;
+SELECT "unsignedtest3", d1, d2 FROM cs6;
+
+# Deletes with comparison operators in WHERE clause
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+DELETE FROM cs4 WHERE d1 >= 99999999999999999999999999999999999998 OR d2 >= 9999999999999999998;
+DELETE FROM cs5 WHERE d1 >= 9999999999999999999999999999.9999999998 OR d2 >= 999999999.9999999998;
+DELETE FROM cs6 WHERE d1 >= 0.99999999999999999999999999999999999998 OR d2 >= 0.9999999999999999998;
+SELECT "unsignedtest4a", d1, d2 FROM cs4;
+SELECT "unsignedtest4a", d1, d2 FROM cs5;
+SELECT "unsignedtest4a", d1, d2 FROM cs6;
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+DELETE FROM cs4 WHERE d1 > 99999999999999999999999999999999999998 OR d2 > 9999999999999999998;
+DELETE FROM cs5 WHERE d1 > 9999999999999999999999999999.9999999998 OR d2 > 999999999.9999999998;
+DELETE FROM cs6 WHERE d1 > 0.99999999999999999999999999999999999998 OR d2 > 0.9999999999999999998;
+SELECT "unsignedtest4", d1, d2 FROM cs4;
+SELECT "unsignedtest4", d1, d2 FROM cs5;
+SELECT "unsignedtest4", d1, d2 FROM cs6;
+
+# Delete with NULL in the WHERE clause
+DELETE FROM cs4 WHERE d1 is NULL;
+DELETE FROM cs5 WHERE d1 is NULL;
+DELETE FROM cs6 WHERE d1 is NULL;
+SELECT "unsignedtest5", d1, d2 FROM cs4;
+SELECT "unsignedtest5", d1, d2 FROM cs5;
+SELECT "unsignedtest5", d1, d2 FROM cs6;
+
+# Delete with != operator
+DELETE FROM cs4 WHERE d1 != 125;
+DELETE FROM cs5 WHERE d1 != 1.25;
+DELETE FROM cs6 WHERE d1 != 0.125;
+SELECT "unsignedtest6", d1, d2 FROM cs4;
+SELECT "unsignedtest6", d1, d2 FROM cs5;
+SELECT "unsignedtest6", d1, d2 FROM cs6;
+
+# Delete with non-constant value in the WHERE clause
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+DELETE FROM cs4 WHERE d1 = d2;
+DELETE FROM cs5 WHERE d1 = d2;
+DELETE FROM cs6 WHERE d1 = d2;
+SELECT "unsignedtest7", d1, d2 FROM cs4;
+SELECT "unsignedtest7", d1, d2 FROM cs5;
+SELECT "unsignedtest7", d1, d2 FROM cs6;
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+DELETE FROM cs4 WHERE d1 != d2;
+DELETE FROM cs5 WHERE d1 != d2;
+DELETE FROM cs6 WHERE d1 != d2;
+SELECT "unsignedtest8", d1, d2 FROM cs4;
+SELECT "unsignedtest8", d1, d2 FROM cs5;
+SELECT "unsignedtest8", d1, d2 FROM cs6;
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+DELETE FROM cs4 WHERE d1 < d2;
+DELETE FROM cs5 WHERE d1 < d2;
+DELETE FROM cs6 WHERE d1 < d2;
+SELECT "unsignedtest9", d1, d2 FROM cs4;
+SELECT "unsignedtest9", d1, d2 FROM cs5;
+SELECT "unsignedtest9", d1, d2 FROM cs6;
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+DELETE FROM cs4 WHERE d1 > d2;
+DELETE FROM cs5 WHERE d1 > d2;
+DELETE FROM cs6 WHERE d1 > d2;
+SELECT "unsignedtest10", d1, d2 FROM cs4;
+SELECT "unsignedtest10", d1, d2 FROM cs5;
+SELECT "unsignedtest10", d1, d2 FROM cs6;
+
+# Deletes with functions and expressions in the WHERE clause
+
+# Clean UP
+DROP PROCEDURE IF EXISTS signedinsertproc;
+DROP PROCEDURE IF EXISTS signeddeleteproc;
+DROP PROCEDURE IF EXISTS unsignedinsertproc;
+DROP PROCEDURE IF EXISTS unsigneddeleteproc;
+DROP DATABASE mcol641_delete_db;
--- a/mysql-test/columnstore/basic/t/mcol641-functions.test
+++ b/mysql-test/columnstore/basic/t/mcol641-functions.test
@ -0,0 +1,618 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS test_mcol641_functions;
+--enable_warnings
+
+CREATE DATABASE test_mcol641_functions;
+USE test_mcol641_functions;
+
+# bitwise functions
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (123, 234), (999999999999999999999999999999, -999999999999999999999999999999), (999999999999999999, -999999999999999999), (1329227995784915872903807060280344576, 1), (-1329227995784915872903807060280344576, 1);
+SELECT "bitwise_and_test", d1 & d2, d1 & d1, d2 & d2, d1 & 10, d2 & 10 FROM cs1;
+SELECT "bitwise_or_test", d1 | d2, d1 | d1, d2 | d2, d1 | 10, d2 | 10 FROM cs1;
+SELECT "bitwise_xor_test", d1 ^ d2, d1 ^ d1, d2 ^ d2, d1 ^ 10, d2 ^ 10 FROM cs1 WHERE d1 != 999999999999999999;
+SELECT "bitwise_leftshift_test", d1 << 1, d1 << 10, d1 << 20, d2 << 1, d2 << 10, d2 << 20 FROM cs1 WHERE d1 <= 999999999999999999;
+SELECT "bitwise_rightshift_test", d1 >> 1, d1 >> 10, d1 >> 20, d2 >> 1, d2 >> 10, d2 >> 20 FROM cs1;
+SELECT "bitcount_test", bit_count(d1), bit_count(d2) FROM cs1;
+
+# period_diff function
+DELETE FROM cs1;
+INSERT INTO cs1 VALUES (2001, 2011), (199001, 199010);
+SELECT "period_diff_test", PERIOD_DIFF(d1, d2), PERIOD_DIFF(d2, d1), PERIOD_DIFF(d1, d1) FROM cs1;
+
+# cast a decimal as signed/unsigned/char
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (123), (-234), (99999999999999999999999999999999999999), (-99999999999999999999999999999999999999), (12345678901234567890123456789012345678), (-12345678901234567890123456789012345678), (1329227995784915872903807060280344576), (-1329227995784915872903807060280344576);
+SELECT "cast_test1", CAST(d1 AS SIGNED) FROM cs1 WHERE d1 > -9223372036854775808; # -9223372036854775808 results in a NULL output
+SELECT "cast_test2", CAST(d1 AS UNSIGNED), CAST(d1 AS CHAR(50)) FROM cs1;
+
+# cast a decimal as date, datetime
+DELETE FROM cs1;
+INSERT INTO cs1 VALUES (20201212), (19901028183200);
+SELECT "cast_test3", CAST(d1 AS DATETIME), CAST(d1 AS DATE) FROM cs1;
+
+# cast a decimal as double
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38,10)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (123), (-123), (123.456), (-123.456), (1234567890123456789012345678.9012345678), (-1234567890123456789012345678.9012345678);
+SELECT "cast_test4", CAST(d1 AS DOUBLE) FROM cs1;
+
+# cast a decimal/int/char/float/double as decimal
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38), d4 BIGINT, d5 CHAR(40), d6 FLOAT, d7 DOUBLE) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (123, 123.456, .123, 123, "123", 123.456, 123.456),
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, .12345678901234567890123456789012345678, 123456789012345678, "12345678901234567890123456789012345678", 1234567890.1234567890, 12345678901234567.123456789012345678),
+(99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, .99999999999999999999999999999999999999, 999999999999999999, "99999999999999999999999999999999999999", 9999999999.9999999999, 99999999999999999999.999999999999999999);
+INSERT INTO cs1(d5) VALUES ("1.1234567890123456789012345e25");
+SELECT "cast_test5", CAST(d1 as DECIMAL(38,0)), CAST(d2 as DECIMAL(38,0)), CAST(d3 as DECIMAL(38,0)), CAST(d4 as DECIMAL(38,0)), CAST(d5 as DECIMAL(38,0)), CAST(d6 as DECIMAL(38,0)), CAST(d7 as DECIMAL(38,0)) FROM cs1;
+SELECT "cast_test5", CAST(d2 as DECIMAL(38,10)), CAST(d3 as DECIMAL(38,10)), CAST(d4 as DECIMAL(38,10)), CAST(d6 as DECIMAL(38,10)) FROM cs1;
+SELECT "cast_test5", CAST(d3 as DECIMAL(38,38)), CAST(d6 as DECIMAL(38,38)), CAST(d7 as DECIMAL(38,38)) FROM cs1;
+
+# inet_ntoa() and inet_aton()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (127), (1278), (1234567890);
+SELECT "inet_test", INET_NTOA(d1) FROM cs1;
+SELECT "inet_test", d1 FROM cs1 where INET_ATON(d1) = d1;
+
+# char()
+DELETE FROM cs1;
+INSERT INTO cs1 VALUES (1296911693), (77);
+SELECT "char_test", CHAR(d1) FROM cs1;
+
+# string functions
+INSERT INTO cs1 VALUES(20201010), (19901230), (1234), (12345);
+SELECT "monthname_test", MONTHNAME(d1), SEC_TO_TIME(d1) FROM cs1;
+
+# real functions
+# abs()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38, 10), d3 DECIMAL(38, 38)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(-123456, -123.456, -0.123456),
+(-99999999999999999999999999999999999999, -9999999999999999999999999999.9999999999, -0.99999999999999999999999999999999999999),
+(NULL, NULL, NULL),
+(-1234, -1234, -0.1234),
+(1234, 1234, 0.1234);
+SELECT "abs_test", ABS(d1), ABS(d2), ABS(d3) FROM cs1;
+
+# round()/truncate()
+DELETE FROM cs1;
+INSERT INTO cs1 VALUES
+(123456, 123.456, 0.123456),
+(-123456, -123.456, -0.123456),
+(9999999999999999999999999999999999999, 999999999999999999999999999.9999999999, 0.9999999999999999999999999999999999999),
+(-9999999999999999999999999999999999999, -999999999999999999999999999.9999999999, -0.9999999999999999999999999999999999999),
+(1234567890123456789012345679012345678, 123456789012345678901234567.9012345678, 0.1234567890123456789012345679012345678),
+(-1234567890123456789012345679012345678, -123456789012345678901234567.9012345678, -0.1234567890123456789012345679012345678),
+(NULL, NULL, NULL);
+SELECT "round_test", ROUND(d1), ROUND(d1,5), ROUND(d1,-5), ROUND(d1,10), ROUND(d1,-10), ROUND(d1,-38) FROM cs1; #ROUND(d1,38) has a bug
+SELECT "round_test", ROUND(d2), ROUND(d2,5), ROUND(d2,-5), ROUND(d2,10), ROUND(d2,-10), ROUND(d2,38), ROUND(d2,-38) FROM cs1;
+SELECT "round_test", ROUND(d3), ROUND(d3,5), ROUND(d3,-5), ROUND(d3,10), ROUND(d3,-10), ROUND(d3,38), ROUND(d3,-38) FROM cs1;
+SELECT "round_test", d2 FROM cs1 WHERE ROUND(d2) = "123"; # triggers getDoubleVal()
+SELECT "truncate_test", TRUNCATE(d1, 0), TRUNCATE(d1,5), TRUNCATE(d1,-5), TRUNCATE(d1,10), TRUNCATE(d1,-10), TRUNCATE(d1,-38) FROM cs1; # TRUNCATE(d1,38) has a bug
+SELECT "truncate_test", TRUNCATE(d2, 0), TRUNCATE(d2,5), TRUNCATE(d2,-5), TRUNCATE(d2,10), TRUNCATE(d2,-10), TRUNCATE(d2,38), TRUNCATE(d2,-38) FROM cs1;
+# See MDEV-22502. Fixed now! So enabling back the test for d3.
+SELECT "truncate_test", TRUNCATE(d3, 0), TRUNCATE(d3,5), TRUNCATE(d3,-5), TRUNCATE(d3,10), TRUNCATE(d3,-10), TRUNCATE(d3,38), TRUNCATE(d3,-38) FROM cs1;
+SELECT "truncate_test", d2 FROM cs1 WHERE TRUNCATE(d2, 0) = "123"; # triggers getDoubleVal()
+
+# format()
+# Commenting out format() tests until MDEV-23118 is fixed.
+#SELECT "format_test", FORMAT(d1, 0), FORMAT(d1, 10), FORMAT(d1, 38),
+#       FORMAT(d2, 0), FORMAT(d2, 10), FORMAT(d2, 38),
+#       FORMAT(d3, 0), FORMAT(d3, 10), FORMAT(d3, 38) FROM cs1;
+
+# mod()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38,5), d2 DECIMAL(38,5), d3 DECIMAL(38), d4 DECIMAL(38), d5 DOUBLE) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(1234.5678, 123.456, 12345678, 123456, 123456),
+(1234567890123456789012345678.90123, 1234567890123456789012345678.90123, 12345678901234567890123456789012345678, 12345678901234567890123456789012345679, 123456781234),
+(-1234.5678, 123.456, -12345678, 123456, -123456),
+(1234567890123456789012345678.90124, -1234567890123456789012345678.90123, 12345678901234567890123456789012345678, -12345678901234567890123456789012345679, 123456781234);
+# MOD(d3,d1) is a floating point division which can result in different results from innodb due to rounding
+# Also, MOD() between decimal and double is excluded from the query as we return the correct result but innodb does not.
+#SELECT "mod_test", MOD(d1,d2), MOD(d2,d1), MOD(d1,d3), MOD(d3,d4), MOD(d4,d3), MOD(d1,d5), MOD(d2,d5), MOD(d3,d5), MOD(d4,d5) FROM cs1;
+SELECT "mod_test", MOD(d1,d2), MOD(d2,d1), MOD(d1,d3), MOD(d3,d4), MOD(d4,d3) FROM cs1;
+
+# floor(), ceil()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38), d4 INT, d5 DOUBLE, d6 DECIMAL(18,10)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, 0.12345678901234567890123456789012345678, 123456, 123456.789, 12345678.9012345678),
+(123456, 123456.789, 0.123456789, 123456, 123456.789, 1234.567),
+# Uncomment the below 2 inserts for 999... when MDEV-23032 is fixed.
+#(99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999, 999999, 99999.999, 99999999.9999999999),
+(999999, 999999.999, 0.9999999, 999999, 999999.999, 9999.999),
+(999999, 999999.999, 0.9999999, 999999, 999998.999, 9999.999),
+(-12345678901234567890123456789012345678, -1234567890123456789012345678.9012345678, -0.12345678901234567890123456789012345678, -123456, -123456.789, -12345678.9012345678),
+(-123456, -123456.789, -0.123456789, -123456, -123456.789, -1234.567),
+#(-99999999999999999999999999999999999999, -9999999999999999999999999999.9999999999, -0.99999999999999999999999999999999999999, -999999, -99999.999, -99999999.9999999999),
+(-999999, -999999.999, -0.9999999, -999999, -999999.999, -9999.999);
+SELECT "floor_test", FLOOR(d1), FLOOR(d2), FLOOR(d3), FLOOR(d4), FLOOR(d5), FLOOR(d6) FROM cs1;
+SELECT "floor_test", d1, d4 FROM cs1 WHERE FLOOR(d1) = FLOOR(d4); # triggers predicateoperator numericCompare()
+SELECT "floor_test", d1, d4 FROM cs1 WHERE FLOOR(d1) = d4;
+SELECT "floor_test", d1, d5 FROM cs1 WHERE FLOOR(d1) = FLOOR(d5);
+SELECT "floor_test", d1, d5 FROM cs1 WHERE FLOOR(d1) = d5; # triggers Func_floor::getDoubleVal()
+SELECT "floor_test", d1, d2 FROM cs1 WHERE FLOOR(d1) = FLOOR(d2);
+
+SELECT "ceil_test", CEIL(d1), CEIL(d2), CEIL(d3), CEIL(d4), CEIL(d5), CEIL(d6) FROM cs1;
+SELECT "ceil_test", d1, d4 FROM cs1 WHERE CEIL(d1) = CEIL(d4); # triggers predicateoperator numericCompare()
+SELECT "ceil_test", d1, d4 FROM cs1 WHERE CEIL(d1) = d4;
+SELECT "ceil_test", d1, d5 FROM cs1 WHERE CEIL(d1) = CEIL(d5);
+SELECT "ceil_test", d1, d5 FROM cs1 WHERE CEIL(d1) = d5; # triggers Func_floor::getDoubleVal()
+SELECT "ceil_test", d1, d2 FROM cs1 WHERE CEIL(d1) = CEIL(d2);
+
+# makedate(), maketime()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38), d4 DECIMAL(20)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (31, 31, 0.31, 2019), (32, 32, 0.32, 2020), (33, 34.7, 0.345, 18);
+SELECT "makedatetime_test", MAKEDATE(d4, d1), MAKEDATE(d4, d2), MAKEDATE(d4, d3), MAKETIME(d4, d2, d1) FROM cs1;
+
+# ELT()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (0, 0.1), (2, 2.1), (1, 1.7), (-1, -1.2);
+SELECT "elt_test", ELT(d1, "FIRST", "SECOND"), ELT(d2, "FIRST", "SECOND") FROM cs1;
+
+# least(), greatest()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38), d4 INT, d5 DOUBLE) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, 0.12345678901234567890123456789012345678, 1234, 1.23e45),
+(-12345678901234567890123456789012345678, -1234567890123456789012345678.9012345678, -0.12345678901234567890123456789012345678, -1234, -1.234e40);
+SELECT "greatest_test", GREATEST(d1, 12345678901234567890123456789012345679) c1, GREATEST(d2, 1234567890123456789012345678.9012345679) c2,
+GREATEST(d3, 0.12345678901234567890123456789012345677) c3, GREATEST(d1, d4) c4 FROM cs1;
+SELECT "greatest_test", d2 FROM cs1 WHERE GREATEST(d2, d5) = d5; # triggers getDoubleVal()
+SELECT "least_test", LEAST(d1, 12345678901234567890123456789012345679) c1, LEAST(d2, 1234567890123456789012345678.9012345679) c2,
+LEAST(d3, 0.12345678901234567890123456789012345677) c3, LEAST(d1, d4) c4 FROM cs1;
+SELECT "least_test", d2 FROM cs1 WHERE LEAST(d2, d5) = d5; # triggers getDoubleVal()
+
+# functor_bool: (not)between, (not)in, regexp, is(not)null, is(not)true, is(not)false
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38, 10), d3 DECIMAL(38, 38)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(123456, 123.456, 0.123456),
+(-123456, -123.456, -0.123456),
+(99999999999999999999999999999999999998, 999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998),
+(-99999999999999999999999999999999999998, -9999999999999999999999999999.9999999998, -0.99999999999999999999999999999999999998),
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, 0.12345678901234567890123456789012345678),
+(-12345678901234567890123456789012345678, -1234567890123456789012345678.9012345678, -0.12345678901234567890123456789012345678),
+(0,0,0),
+(NULL, NULL, NULL);
+
+SELECT "between_test", d1 BETWEEN 123455 AND 123457 f1,
+d2 BETWEEN 999999999999999999999999999.9999999997 AND 999999999999999999999999999.9999999999 f2,
+d3 BETWEEN -0.12345678901234567890123456789012345679 AND -0.12345678901234567890123456789012345677 f3 FROM cs1;
+
+SELECT "notbetween_test", d1 NOT BETWEEN 123455 AND 123457 f1,
+d2 NOT BETWEEN 999999999999999999999999999.9999999997 AND 999999999999999999999999999.9999999999 f2,
+d3 NOT BETWEEN -0.12345678901234567890123456789012345679 AND -0.12345678901234567890123456789012345677 f3 FROM cs1;
+
+SELECT "in_test", d1 IN (99999999999999999999999999999999999998, -12345678901234567890123456789012345678) f1,
+d2 IN (-9999999999999999999999999999.9999999998, 1234567890123456789012345678.9012345678) f2,
+d3 IN (-0.99999999999999999999999999999999999998, -0.12345678901234567890123456789012345678) f3 FROM cs1;
+
+SELECT "notin_test", d1 NOT IN (99999999999999999999999999999999999998, -12345678901234567890123456789012345678) f1,
+d2 NOT IN (-9999999999999999999999999999.9999999998, 1234567890123456789012345678.9012345678) f2,
+d3 NOT IN (-0.99999999999999999999999999999999999998, -0.12345678901234567890123456789012345678) f3 FROM cs1;
+
+SELECT "regex_test", d1 REGEXP "123", d2 REGEXP "8.9", d3 REGEXP "0.9" FROM cs1;
+
+SELECT "is(not)null_test", d1 IS NULL, d1 IS NOT NULL, d2 IS NULL, d2 IS NOT NULL, d3 IS NULL, d3 IS NOT NULL FROM cs1;
+
+SELECT "truthfunctions_test", d1 IS TRUE AS f1, d1 IS NOT TRUE AS f2, d1 IS FALSE AS f3, d1 IS NOT FALSE AS f4,
+d2 IS TRUE AS f5, d2 IS NOT TRUE AS f6, d2 IS FALSE AS f7, d2 IS NOT FALSE AS f8,
+d3 IS TRUE AS f9, d3 IS NOT TRUE AS f10, d3 IS FALSE AS f11, d3 IS NOT FALSE AS f12 FROM cs1;
+
+# if()/coalesce()
+# for the case "select if(a, b, c)" where a=decimal(38), b=decimal(38,10), c=decimal(38,38),
+# we can have an overflow, since the resulting column can be of type decimal(M,D) where M > 38
+# which we currently do not support in ColumnStore. Same is true for coalesce.
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38, 10), d2 DECIMAL(38, 10), d3 DECIMAL(38, 10)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(0, 1234567890123456789012345678.9012345678, -1234567890123456789012345678.9012345678),
+(1234567890123456789012345678.9012345678, 0, -1234567890123456789012345678.9012345678),
+(1234567890123456789012345678.9012345678, -1234567890123456789012345678.9012345678, 0),
+(NULL, -9999999999999999999999999999.9999999998, 9999999999999999999999999999.9999999998),
+(-9999999999999999999999999999.9999999998, NULL, 9999999999999999999999999999.9999999998),
+(-9999999999999999999999999999.9999999998, 9999999999999999999999999999.9999999998, NULL),
+(NULL, NULL, NULL);
+
+SELECT "if_test", IF(d1, d2, d3) AS f1, IF(d1, d3, d2) AS f2, IF(d2, d1, d3) AS f3, IF(d2, d3, d1) AS f4,
+IF(d3, d1, d2) AS f5, IF(d3, d2, d1) AS f6 FROM cs1;
+
+SELECT "coalesce_test", COALESCE(d1, d2, d3) AS f1, COALESCE(d1, d3, d2) AS f2, COALESCE(d2, d1, d3) AS f3,
+COALESCE(d2, d3, d1) AS f4, COALESCE(d3, d1, d2) AS f5, COALESCE(d3, d2, d1) AS f6 FROM cs1;
+
+# case()
+SELECT "case_test", CASE d1 WHEN 1234567890123456789012345678.9012345678 THEN d2 ELSE d3 END AS f1,
+       CASE d2 WHEN -1234567890123456789012345678.9012345678 THEN d1 ELSE d3 END AS f2,
+       CASE d3 WHEN -d1 THEN 9999999999999999999999999999.9999999999 ELSE -9999999999999999999999999999.9999999999 END AS f3
+FROM cs1;
+
+# repeat the tests for unsigned
+# bitwise functions
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (123, 234), (999999999999999999999999999999, 999999999999999999999999999998), (999999999999999999, 999999999999999998), (1329227995784915872903807060280344576, 1), (1, 1329227995784915872903807060280344576);
+SELECT "bitwise_and_test", d1 & d2, d1 & d1, d2 & d2, d1 & 10, d2 & 10 FROM cs1;
+SELECT "bitwise_or_test", d1 | d2, d1 | d1, d2 | d2, d1 | 10, d2 | 10 FROM cs1;
+# The d1 ^ d2 produces 18446744073709551614 that is the magic value for UBIGINT NULL
+SELECT "bitwise_xor_test", d1 ^ d2, d1 ^ d1, d2 ^ d2, d1 ^ 10, d2 ^ 10 FROM cs1 WHERE d1 != 999999999999999999;
+# The d1 << 1 produces 18446744073709551614 that is the magic value for UBIGINT NULL
+SELECT "bitwise_leftshift_test", d1 << 1, d1 << 10, d1 << 20, d2 << 1, d2 << 10, d2 << 20 FROM cs1 WHERE d1 <= 999999999999999999;
+SELECT "bitwise_rightshift_test", d1 >> 1, d1 >> 10, d1 >> 20, d2 >> 1, d2 >> 10, d2 >> 20 FROM cs1;
+SELECT "bitcount_test", bit_count(d1), bit_count(d2) FROM cs1;
+
+# period_diff function
+DELETE FROM cs1;
+INSERT INTO cs1 VALUES (2001, 2011), (199001, 199010);
+SELECT "period_diff_test", PERIOD_DIFF(d1, d2), PERIOD_DIFF(d2, d1), PERIOD_DIFF(d1, d1) FROM cs1;
+
+# cast a decimal as signed/unsigned/char
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (123), (234), (99999999999999999999999999999999999999), (99999999999999999999999999999999999998), (12345678901234567890123456789012345678), (12345678901234567890123456789012345679), (1329227995784915872903807060280344576), (1329227995784915872903807060280344577);
+SELECT "cast_test1", CAST(d1 AS SIGNED) FROM cs1 WHERE d1 > 12345678901234567890123456789012345678;
+SELECT "cast_test2", CAST(d1 AS UNSIGNED), CAST(d1 AS CHAR(50)) FROM cs1;
+
+# cast a decimal as date, datetime
+DELETE FROM cs1;
+INSERT INTO cs1 VALUES (20201212), (19901028183200);
+SELECT "cast_test3", CAST(d1 AS DATETIME), CAST(d1 AS DATE) FROM cs1;
+
+# cast a decimal as double
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38,10) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (123), (234), (123.456), (234.567), (1234567890123456789012345678.9012345678), (9999999999999999999999999999.9999999999);
+SELECT "cast_test4", CAST(d1 AS DOUBLE) FROM cs1;
+
+# cast a decimal/int/char/float/double as decimal
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED, d4 BIGINT UNSIGNED, d5 CHAR(40), d6 FLOAT UNSIGNED, d7 DOUBLE UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (123, 123.456, .123, 123, "123", 123.456, 123.456),
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, .12345678901234567890123456789012345678, 123456789012345678, "12345678901234567890123456789012345678", 1234567890.1234567890, 12345678901234567.123456789012345678),
+(99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, .99999999999999999999999999999999999999, 999999999999999999, "99999999999999999999999999999999999999", 9999999999.9999999999, 99999999999999999999.999999999999999999);
+INSERT INTO cs1(d5) VALUES ("1.1234567890123456789012345e25");
+SELECT "cast_test5", CAST(d1 as DECIMAL(38,0)), CAST(d2 as DECIMAL(38,0)), CAST(d3 as DECIMAL(38,0)), CAST(d4 as DECIMAL(38,0)), CAST(d5 as DECIMAL(38,0)), CAST(d6 as DECIMAL(38,0)), CAST(d7 as DECIMAL(38,0)) FROM cs1;
+SELECT "cast_test5", CAST(d2 as DECIMAL(38,10)), CAST(d3 as DECIMAL(38,10)), CAST(d4 as DECIMAL(38,10)), CAST(d6 as DECIMAL(38,10)) FROM cs1;
+SELECT "cast_test5", CAST(d3 as DECIMAL(38,38)), CAST(d6 as DECIMAL(38,38)), CAST(d7 as DECIMAL(38,38)) FROM cs1;
+
+# inet_ntoa() and inet_aton()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (127), (1278), (1234567890);
+SELECT "inet_test", INET_NTOA(d1) FROM cs1;
+SELECT "inet_test", d1 FROM cs1 where INET_ATON(d1) = d1;
+
+# char()
+DELETE FROM cs1;
+INSERT INTO cs1 VALUES (1296911693), (77);
+SELECT "char_test", CHAR(d1) FROM cs1;
+
+# string functions
+INSERT INTO cs1 VALUES(20201010), (19901230), (1234), (12345);
+SELECT "monthname_test", MONTHNAME(d1), SEC_TO_TIME(d1) FROM cs1;
+
+# real functions
+# abs()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38, 10) UNSIGNED, d3 DECIMAL(38, 38) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(123456, 123.456, 0.123456),
+(99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999),
+(NULL, NULL, NULL),
+(1234, 1234, 0.1234),
+(1234, 1234, 0.1234);
+SELECT "abs_test", ABS(d1), ABS(d2), ABS(d3) FROM cs1;
+
+# round()/truncate()
+DELETE FROM cs1;
+INSERT INTO cs1 VALUES
+(123456, 123.456, 0.123456),
+(9999999999999999999999999999999999999, 999999999999999999999999999.9999999999, 0.9999999999999999999999999999999999999),
+(1234567890123456789012345679012345678, 123456789012345678901234567.9012345678, 0.1234567890123456789012345679012345678),
+(NULL, NULL, NULL);
+SELECT "round_test", ROUND(d1), ROUND(d1,5), ROUND(d1,-5), ROUND(d1,10), ROUND(d1,-10), ROUND(d1,-38) FROM cs1; #ROUND(d1,38) has a bug
+SELECT "round_test", ROUND(d2), ROUND(d2,5), ROUND(d2,-5), ROUND(d2,10), ROUND(d2,-10), ROUND(d2,38), ROUND(d2,-38) FROM cs1;
+SELECT "round_test", ROUND(d3), ROUND(d3,5), ROUND(d3,-5), ROUND(d3,10), ROUND(d3,-10), ROUND(d3,38), ROUND(d3,-38) FROM cs1;
+SELECT "round_test", d2 FROM cs1 WHERE ROUND(d2) = "123"; # triggers getDoubleVal()
+SELECT "truncate_test", TRUNCATE(d1, 0), TRUNCATE(d1,5), TRUNCATE(d1,-5), TRUNCATE(d1,10), TRUNCATE(d1,-10), TRUNCATE(d1,-38) FROM cs1; # TRUNCATE(d1,38) has a bug
+SELECT "truncate_test", TRUNCATE(d2, 0), TRUNCATE(d2,5), TRUNCATE(d2,-5), TRUNCATE(d2,10), TRUNCATE(d2,-10), TRUNCATE(d2,38), TRUNCATE(d2,-38) FROM cs1;
+# See MDEV-22502. Fixed now! So enabling back the test for d3.
+SELECT "truncate_test", TRUNCATE(d3, 0), TRUNCATE(d3,5), TRUNCATE(d3,-5), TRUNCATE(d3,10), TRUNCATE(d3,-10), TRUNCATE(d3,38), TRUNCATE(d3,-38) FROM cs1;
+SELECT "truncate_test", d2 FROM cs1 WHERE TRUNCATE(d2, 0) = "123"; # triggers getDoubleVal()
+
+# format()
+# Commenting out format() tests until MDEV-23118 is fixed.
+#SELECT "format_test", FORMAT(d1, 0), FORMAT(d1, 10), FORMAT(d1, 38),
+#       FORMAT(d2, 0), FORMAT(d2, 10), FORMAT(d2, 38),
+#       FORMAT(d3, 0), FORMAT(d3, 10), FORMAT(d3, 38) FROM cs1;
+
+# mod()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38,5) UNSIGNED, d2 DECIMAL(38,5) UNSIGNED, d3 DECIMAL(38) UNSIGNED, d4 DECIMAL(38) UNSIGNED, d5 DOUBLE UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(1234.5678, 123.456, 12345678, 123456, 123456),
+(1234567890123456789012345678.90123, 1234567890123456789012345678.90123, 12345678901234567890123456789012345678, 12345678901234567890123456789012345679, 123456781234);
+# MOD(d3,d1) is a floating point division which can result in different results from innodb due to rounding
+# Also, MOD() between decimal and double is excluded from the query as we return the correct result but innodb does not.
+#SELECT "mod_test", MOD(d1,d2), MOD(d2,d1), MOD(d1,d3), MOD(d3,d4), MOD(d4,d3), MOD(d1,d5), MOD(d2,d5), MOD(d3,d5), MOD(d4,d5) FROM cs1;
+SELECT "mod_test", MOD(d1,d2), MOD(d2,d1), MOD(d1,d3), MOD(d3,d4), MOD(d4,d3) FROM cs1;
+
+# floor(), ceil()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED, d4 INT UNSIGNED, d5 DOUBLE UNSIGNED, d6 DECIMAL(18,10) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, 0.12345678901234567890123456789012345678, 123456, 123456.789, 12345678.9012345678),
+(123456, 123456.789, 0.123456789, 123456, 123456.789, 1234.567),
+# Uncomment the below 2 inserts for 999... when MDEV-23032 is fixed.
+#(99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999, 999999, 99999.999, 99999999.9999999999),
+(999999, 999999.999, 0.9999999, 999999, 999999.999, 9999.999),
+(999999, 999999.999, 0.9999999, 999999, 999998.999, 9999.999);
+#(-99999999999999999999999999999999999999, -9999999999999999999999999999.9999999999, -0.99999999999999999999999999999999999999, -999999, -99999.999, -99999999.9999999999),
+SELECT "floor_test", FLOOR(d1), FLOOR(d2), FLOOR(d3), FLOOR(d4), FLOOR(d5), FLOOR(d6) FROM cs1;
+SELECT "floor_test", d1, d4 FROM cs1 WHERE FLOOR(d1) = FLOOR(d4); # triggers predicateoperator numericCompare()
+SELECT "floor_test", d1, d4 FROM cs1 WHERE FLOOR(d1) = d4;
+SELECT "floor_test", d1, d5 FROM cs1 WHERE FLOOR(d1) = FLOOR(d5);
+SELECT "floor_test", d1, d5 FROM cs1 WHERE FLOOR(d1) = d5; # triggers Func_floor::getDoubleVal()
+SELECT "floor_test", d1, d2 FROM cs1 WHERE FLOOR(d1) = FLOOR(d2);
+
+SELECT "ceil_test", CEIL(d1), CEIL(d2), CEIL(d3), CEIL(d4), CEIL(d5), CEIL(d6) FROM cs1;
+SELECT "ceil_test", d1, d4 FROM cs1 WHERE CEIL(d1) = CEIL(d4); # triggers predicateoperator numericCompare()
+SELECT "ceil_test", d1, d4 FROM cs1 WHERE CEIL(d1) = d4;
+SELECT "ceil_test", d1, d5 FROM cs1 WHERE CEIL(d1) = CEIL(d5);
+SELECT "ceil_test", d1, d5 FROM cs1 WHERE CEIL(d1) = d5; # triggers Func_floor::getDoubleVal()
+SELECT "ceil_test", d1, d2 FROM cs1 WHERE CEIL(d1) = CEIL(d2);
+
+# makedate(), maketime()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED, d4 DECIMAL(20) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (31, 31, 0.31, 2019), (32, 32, 0.32, 2020), (33, 34.7, 0.345, 18);
+SELECT "makedatetime_test", MAKEDATE(d4, d1), MAKEDATE(d4, d2), MAKEDATE(d4, d3), MAKETIME(d4, d2, d1) FROM cs1;
+
+# ELT()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (0, 0.1), (2, 2.1), (1, 1.7), (1, 1.2);
+SELECT "elt_test", ELT(d1, "FIRST", "SECOND"), ELT(d2, "FIRST", "SECOND") FROM cs1;
+
+# least(), greatest()
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED, d4 INT UNSIGNED, d5 DOUBLE UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, 0.12345678901234567890123456789012345678, 1234, 1.23e45);
+SELECT "greatest_test", GREATEST(d1, 12345678901234567890123456789012345679) c1, GREATEST(d2, 1234567890123456789012345678.9012345679) c2,
+GREATEST(d3, 0.12345678901234567890123456789012345677) c3, GREATEST(d1, d4) c4 FROM cs1;
+SELECT "greatest_test", d2 FROM cs1 WHERE GREATEST(d2, d5) = d5; # triggers getDoubleVal()
+SELECT "least_test", LEAST(d1, 12345678901234567890123456789012345679) c1, LEAST(d2, 1234567890123456789012345678.9012345679) c2,
+LEAST(d3, 0.12345678901234567890123456789012345677) c3, LEAST(d1, d4) c4 FROM cs1;
+SELECT "least_test", d2 FROM cs1 WHERE LEAST(d2, d5) = d5; # triggers getDoubleVal()
+
+# functor_bool: (not)between, (not)in, regexp, is(not)null, is(not)true, is(not)false
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38, 10) UNSIGNED, d3 DECIMAL(38, 38) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(123456, 123.456, 0.123456),
+(99999999999999999999999999999999999998, 999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998),
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, 0.12345678901234567890123456789012345678),
+(0,0,0),
+(NULL, NULL, NULL);
+
+SELECT "between_test", d1 BETWEEN 123455 AND 123457 f1,
+d2 BETWEEN 999999999999999999999999999.9999999997 AND 999999999999999999999999999.9999999999 f2,
+d3 BETWEEN 0.12345678901234567890123456789012345679 AND 0.12345678901234567890123456789012345677 f3 FROM cs1;
+
+SELECT "notbetween_test", d1 NOT BETWEEN 123455 AND 123457 f1,
+d2 NOT BETWEEN 999999999999999999999999999.9999999997 AND 999999999999999999999999999.9999999999 f2,
+d3 NOT BETWEEN 0.12345678901234567890123456789012345679 AND 0.12345678901234567890123456789012345677 f3 FROM cs1;
+
+SELECT "in_test", d1 IN (99999999999999999999999999999999999998, 12345678901234567890123456789012345678) f1,
+d2 IN (9999999999999999999999999999.9999999998, 123.456) f2,
+d3 IN (0.123456, 0.12345678901234567890123456789012345678) f3 FROM cs1;
+
+SELECT "notin_test", d1 NOT IN (99999999999999999999999999999999999998, 12345678901234567890123456789012345678) f1,
+d2 NOT IN (9999999999999999999999999999.9999999998, 123.456) f2,
+d3 NOT IN (0.123456, 0.12345678901234567890123456789012345678) f3 FROM cs1;
+
+SELECT "regex_test", d1 REGEXP "123", d2 REGEXP "8.9", d3 REGEXP "0.9" FROM cs1;
+
+SELECT "is(not)null_test", d1 IS NULL, d1 IS NOT NULL, d2 IS NULL, d2 IS NOT NULL, d3 IS NULL, d3 IS NOT NULL FROM cs1;
+
+SELECT "truthfunctions_test", d1 IS TRUE AS f1, d1 IS NOT TRUE AS f2, d1 IS FALSE AS f3, d1 IS NOT FALSE AS f4,
+d2 IS TRUE AS f5, d2 IS NOT TRUE AS f6, d2 IS FALSE AS f7, d2 IS NOT FALSE AS f8,
+d3 IS TRUE AS f9, d3 IS NOT TRUE AS f10, d3 IS FALSE AS f11, d3 IS NOT FALSE AS f12 FROM cs1;
+
+# if()/coalesce()
+# for the case "select if(a, b, c)" where a=decimal(38), b=decimal(38,10), c=decimal(38,38),
+# we can have an overflow, since the resulting column can be of type decimal(M,D) where M > 38
+# which we currently do not support in ColumnStore. Same is true for coalesce.
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38, 10) UNSIGNED, d2 DECIMAL(38, 10) UNSIGNED, d3 DECIMAL(38, 10) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES
+(0, 1234567890123456789012345678.9012345678, 1234567890123456789012345678.9012345679),
+(1234567890123456789012345678.9012345678, 0, 1234567890123456789012345678.9012345679),
+(1234567890123456789012345678.9012345678, 1234567890123456789012345678.9012345679, 0),
+(NULL, 9999999999999999999999999999.9999999999, 9999999999999999999999999999.9999999998),
+(9999999999999999999999999999.9999999999, NULL, 9999999999999999999999999999.9999999998),
+(9999999999999999999999999999.9999999999, 9999999999999999999999999999.9999999998, NULL),
+(NULL, NULL, NULL);
+
+SELECT "if_test", IF(d1, d2, d3) AS f1, IF(d1, d3, d2) AS f2, IF(d2, d1, d3) AS f3, IF(d2, d3, d1) AS f4,
+IF(d3, d1, d2) AS f5, IF(d3, d2, d1) AS f6 FROM cs1;
+
+SELECT "coalesce_test", COALESCE(d1, d2, d3) AS f1, COALESCE(d1, d3, d2) AS f2, COALESCE(d2, d1, d3) AS f3,
+COALESCE(d2, d3, d1) AS f4, COALESCE(d3, d1, d2) AS f5, COALESCE(d3, d2, d1) AS f6 FROM cs1;
+
+# case()
+SELECT "case_test", CASE d1 WHEN 1234567890123456789012345678.9012345678 THEN d2 ELSE d3 END AS f1,
+       CASE d2 WHEN 1234567890123456789012345678.9012345679 THEN d1 ELSE d3 END AS f2,
+       CASE d3 WHEN d1 + 0.0000000001 THEN 9999999999999999999999999999.9999999999 ELSE -9999999999999999999999999999.9999999999 END AS f3
+FROM cs1;
+
+--disable_warnings
+DROP TABLE IF EXISTS cs1;
+DROP TABLE IF EXISTS cs2;
+--enable_warnings
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38, 10), d3 DECIMAL(38, 38)) ENGINE=columnstore;
+CREATE TABLE cs2 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38, 10) UNSIGNED, d3 DECIMAL(38, 38) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs1 VALUES 
+(NULL, NULL, NULL),
+(0,0,0),
+(-99999999999999999999999999999999999998, -9999999999999999999999999999.9999999998, -0.99999999999999999999999999999999999998),
+(-12345678901234567890123456789012345678, -1234567890123456789012345678.9012345678, -0.12345678901234567890123456789012345678),
+(-123456, -123.456, -0.123456),
+(123456, 123.456, 0.123456),
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, 0.12345678901234567890123456789012345678),
+(99999999999999999999999999999999999998, 999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998);
+INSERT INTO cs2 VALUES 
+(NULL, NULL, NULL),
+(0,0,0),
+(123456, 123.456, 0.123456),
+(12345678901234567890123456789012345678, 1234567890123456789012345678.9012345678, 0.12345678901234567890123456789012345678),
+(99999999999999999999999999999999999999, 999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999);
+
+# ACOS(), ASIN(), ATAN()
+# signed
+SELECT "acos_test", ACOS(d1), ACOS(d2), ACOS(d3) FROM cs1;
+SELECT "asin_test", ASIN(d1), ASIN(d2), ASIN(d3) FROM cs1;
+SELECT "atan_test", ATAN(d1), ATAN(d2), ATAN(d3) FROM cs1;
+# unsigned
+SELECT "acos_test", ACOS(d1), ACOS(d2), ACOS(d3) FROM cs2;
+SELECT "asin_test", ASIN(d1), ASIN(d2), ASIN(d3) FROM cs2;
+SELECT "atan_test", ATAN(d1), ATAN(d2), ATAN(d3) FROM cs2;
+
+# SIN(), COS(), COT(), TAN()
+# signed
+# Remove the TRUNCATE() wrapper from the below once MCOL-4811 is fixed.
+SELECT "cos_test", TRUNCATE(COS(d1), 15), COS(d2), COS(d3) FROM cs1;
+SELECT "sin_test", SIN(d1), SIN(d2), SIN(d3) FROM cs1;
+SELECT "tan_test", TAN(d1), TAN(d2), TAN(d3) FROM cs1;
+# unsigned
+# Remove the TRUNCATE() wrapper from the below once MCOL-4811 is fixed.
+SELECT "cos_test", TRUNCATE(COS(d1), 15), COS(d2), COS(d3) FROM cs2;
+SELECT "sin_test", SIN(d1), SIN(d2), SIN(d3) FROM cs2;
+SELECT "tan_test", TAN(d1), TAN(d2), TAN(d3) FROM cs2;
+
+# MD5(), SHA1(), SHA()
+# signed
+SELECT "md5_test", MD5(d1), MD5(d2), MD5(d3) FROM cs1;
+SELECT "sha1_test", SHA1(d1), SHA1(d2), SHA1(d3) FROM cs1;
+SELECT "sha_test", SHA(d1), SHA(d2), SHA(d3) FROM cs1;
+# unsigned
+SELECT "md5_test", MD5(d1), MD5(d2), MD5(d3) FROM cs2;
+SELECT "sha1_test", SHA1(d1), SHA1(d2), SHA1(d3) FROM cs2;
+SELECT "sha_test", SHA(d1), SHA(d2), SHA(d3) FROM cs2;
+
+# CEILING()
+# signed
+SELECT "ceiling_test", CEILING(d1), CEILING(d2), CEILING(d3) FROM cs1;
+# unsigned
+SELECT "ceiling_test", CEILING(d1), CEILING(d2), CEILING(d3) FROM cs2;
+
+# SIGN()
+# signed
+SELECT "sign_test", SIGN(d1), SIGN(d2), SIGN(d3) FROM cs1;
+# unsigned
+SELECT "sign_test", SIGN(d1), SIGN(d2), SIGN(d3) FROM cs2;
+
+# CONCAT_WS(), CONV(), CONVERT()
+# signed
+SELECT "concat_ws_test", CONCAT_WS(' = d1, d2 = ', d1, d2) FROM cs1;
+SELECT "convert_test", CONVERT(d1, SIGNED), CONVERT(d2, SIGNED), CONVERT(d3, SIGNED) FROM cs1;
+SELECT "conv_test", CONV(d1, 10, 8), CONV(d2, 10, 8), CONV(d3, 10, 8) FROM cs1;
+# unsigned
+SELECT "concat_ws_test", CONCAT_WS(' = d2, d3 = ', d2, d3) FROM cs2;
+SELECT "convert_test", CONVERT(d1, SIGNED), CONVERT(d2, SIGNED), CONVERT(d3, SIGNED) FROM cs2;
+SELECT "conv_test", CONV(d1, 10, 8), CONV(d2, 10, 8), CONV(d3, 10, 8) FROM cs2;
+
+#REVERSE(), STRCMP(), REPEAT()
+# signed
+SELECT "reverse_test", REVERSE(d1), REVERSE(d2), REVERSE(d3) FROM cs1;
+SELECT "strcmp_test", STRCMP(d1, d2), STRCMP(d2, d3), STRCMP(d3, d1), STRCMP(d1, 123456) FROM cs1;
+# unsigned
+SELECT "reverse_test", REVERSE(d1), REVERSE(d2), REVERSE(d3) FROM cs2;
+SELECT "strcmp_test", STRCMP(d1, d2), STRCMP(d2, d3), STRCMP(d3, d1), STRCMP(d1, 123456) FROM cs2;
+SELECT "repeat_test", REPEAT(d3, 2) FROM cs2;
+
+# CRC32(), DEGREES(), RADIANS()
+# signed
+SELECT "crc32_test", CRC32(d1), CRC32(d2), CRC32(d3) FROM cs1;
+SELECT "degrees_test", DEGREES(d1), DEGREES(d2), DEGREES(d3) FROM cs1;
+SELECT "radians_test", RADIANS(d1), RADIANS(d2), RADIANS(d3) FROM cs1;
+# usigned
+SELECT "crc32_test", CRC32(d1), CRC32(d2), CRC32(d3) FROM cs2;
+SELECT "degrees_test", DEGREES(d1), DEGREES(d2), DEGREES(d3) FROM cs2;
+SELECT "radians_test", RADIANS(d1), RADIANS(d2), RADIANS(d3) FROM cs2;
+
+# HEX()
+# signed
+SELECT "hex_test", HEX(d1), HEX(d2), HEX(d3) FROM cs1;
+# unsigned
+SELECT "hex_test", HEX(d1), HEX(d2), HEX(d3) FROM cs2;
+
+# INSERT()
+# signed
+SELECT "insert_test", INSERT(d1,6,1,d2), INSERT(d2,0,1,d3) FROM cs1;
+# usigned
+SELECT "insert_test", INSERT(d1,6,1,d2), INSERT(d2,0,1,d3) FROM cs2;
+
+DROP DATABASE test_mcol641_functions;
--- a/mysql-test/columnstore/basic/t/mcol641-insert.test
+++ b/mysql-test/columnstore/basic/t/mcol641-insert.test
@ -0,0 +1,230 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS mcol641_insert_db;
+--enable_warnings
+
+CREATE DATABASE mcol641_insert_db;
+USE mcol641_insert_db;
+
+# Tests for inserts, as well as INSERT ... SELECT and LDI.
+SET SQL_MODE='ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION';
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38),
+                  d4 DECIMAL(19), d5 DECIMAL(19,10), d6 DECIMAL(19,19)) ENGINE=columnstore;
+CREATE TABLE cs2 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED,
+                  d4 DECIMAL(19) UNSIGNED, d5 DECIMAL(19,10) UNSIGNED, d6 DECIMAL(19,19) UNSIGNED) ENGINE=columnstore;
+# cs3 is same as cs1, used as the destination of INSERT...SELECT
+CREATE TABLE cs3 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38),
+                  d4 DECIMAL(19), d5 DECIMAL(19,10), d6 DECIMAL(19,19)) ENGINE=columnstore;
+# cs4 is same as cs2, used as the destination of INSERT...SELECT
+CREATE TABLE cs4 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED,
+                  d4 DECIMAL(19) UNSIGNED, d5 DECIMAL(19,10) UNSIGNED, d6 DECIMAL(19,19) UNSIGNED) ENGINE=columnstore;
+
+#
+# single value inserts
+#
+# simple inserts
+INSERT INTO cs1 VALUES (125, 1.25, 0.125, 125, 1.25, 0.125);
+INSERT INTO cs1 VALUES (-125, -1.25, -0.125, -125, -1.25, -0.125);
+INSERT INTO cs1 VALUES (1.25, 125, 125, 1.25, 125, 125);
+INSERT INTO cs1 VALUES (-1.25, -125, -125, -1.25, -125, -125);
+
+# insert maximum positive and negative values
+INSERT INTO cs1 values (99999999999999999999999999999999999998, 9999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998, 9999999999999999998, 999999999.9999999998, 0.9999999999999999998);
+INSERT INTO cs1 values (99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999, 9999999999999999999, 999999999.9999999999, 0.9999999999999999999);
+INSERT INTO cs1 values (-99999999999999999999999999999999999998, -9999999999999999999999999999.9999999998, -0.99999999999999999999999999999999999998, -9999999999999999998, -999999999.9999999998, -0.9999999999999999998);
+INSERT INTO cs1 values (-99999999999999999999999999999999999999, -9999999999999999999999999999.9999999999, -0.99999999999999999999999999999999999999, -9999999999999999999, -999999999.9999999999, -0.9999999999999999999);
+
+# check saturation of positive and negative values
+INSERT INTO cs1 VALUES (123456789012345678901234567890123456789, 12345678901234567890123456789.12345678912, 0.123456789012345678901234567890123456789, 12345678901234567890, 1234567890.12345678901, 0.12345678901234567891);
+INSERT INTO cs1 VALUES (-123456789012345678901234567890123456789, -12345678901234567890123456789.12345678912, -0.123456789012345678901234567890123456789, -12345678901234567890, -1234567890.12345678901, -0.12345678901234567891);
+
+# check rounding when scale > 0
+INSERT INTO cs1 VALUES (0, 1.12345678919, 0.123456789012345678901234567890123456789, 0, 1.12345678919, 0.12345678901234567899);
+INSERT INTO cs1 VALUES (0, 1.12345678914, 0.123456789012345678901234567890123456784, 0, 1.12345678914, 0.12345678901234567894);
+INSERT INTO cs1 VALUES (0, 1.99999999999, 0.999999999999999999999999999999999999999, 0, 1.99999999999, 0.99999999999999999999);
+INSERT INTO cs1 VALUES (0, 1.99999999994, 0.999999999999999999999999999999999999994, 0, 1.99999999994, 0.99999999999999999994);
+INSERT INTO cs1 VALUES (0, -1.12345678919, -0.123456789012345678901234567890123456789, 0, -1.12345678919, -0.12345678901234567899);
+INSERT INTO cs1 VALUES (0, -1.12345678914, -0.123456789012345678901234567890123456784, 0, -1.12345678914, -0.12345678901234567894);
+INSERT INTO cs1 VALUES (0, -1.99999999999, -0.999999999999999999999999999999999999999, 0, -1.99999999999, -0.99999999999999999999);
+INSERT INTO cs1 VALUES (0, -1.99999999994, -0.999999999999999999999999999999999999994, 0, -1.99999999994, -0.99999999999999999994);
+
+# insert values with leading zeros in the scale
+INSERT INTO cs1 VALUES (0, 1.0000000009, 0.00000000000000000000000000000000000009, 0, 1.0000000009, 0.0000000000000000009);
+INSERT INTO cs1 VALUES (0, 1.00000000009, 0.000000000000000000000000000000000000009, 0, 1.00000000009, 0.00000000000000000009);
+INSERT INTO cs1 VALUES (0, -1.0000000009, -0.00000000000000000000000000000000000009, 0, -1.0000000009, -0.0000000000000000009);
+INSERT INTO cs1 VALUES (0, -1.00000000009, -0.000000000000000000000000000000000000009, 0, -1.00000000009, -0.00000000000000000009);
+
+# insert all zeros
+INSERT INTO cs1 VALUES (0, 0, 0, 0, 0, 0);
+
+# insert all nulls
+INSERT INTO cs1 VALUES (NULL, NULL, NULL, NULL, NULL, NULL);
+INSERT INTO cs1 VALUES ();
+SELECT "test1", d1, d2, d3, d4, d5, d6 FROM cs1;
+
+#
+# multi-value inserts. repeat queries for single-value inserts
+#
+# simple inserts
+DROP TABLE IF EXISTS cs1;
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38),
+                  d4 DECIMAL(19), d5 DECIMAL(19,10), d6 DECIMAL(19,19)) ENGINE=columnstore;
+INSERT INTO cs1 VALUES (125, 1.25, 0.125, 125, 1.25, 0.125),
+(-125, -1.25, -0.125, -125, -1.25, -0.125),
+(1.25, 125, 125, 1.25, 125, 125),
+(-1.25, -125, -125, -1.25, -125, -125);
+
+# insert maximum positive and negative values
+INSERT INTO cs1 values (99999999999999999999999999999999999998, 9999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998, 9999999999999999998, 999999999.9999999998, 0.9999999999999999998),
+(99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999, 9999999999999999999, 999999999.9999999999, 0.9999999999999999999),
+(-99999999999999999999999999999999999998, -9999999999999999999999999999.9999999998, -0.99999999999999999999999999999999999998, -9999999999999999998, -999999999.9999999998, -0.9999999999999999998),
+(-99999999999999999999999999999999999999, -9999999999999999999999999999.9999999999, -0.99999999999999999999999999999999999999, -9999999999999999999, -999999999.9999999999, -0.9999999999999999999);
+
+# check saturation of positive and negative values
+INSERT INTO cs1 VALUES (123456789012345678901234567890123456789, 12345678901234567890123456789.12345678912, 0.123456789012345678901234567890123456789, 12345678901234567890, 1234567890.12345678901, 0.12345678901234567891),
+(-123456789012345678901234567890123456789, -12345678901234567890123456789.12345678912, -0.123456789012345678901234567890123456789, -12345678901234567890, -1234567890.12345678901, -0.12345678901234567891);
+
+# check rounding when scale > 0
+INSERT INTO cs1 VALUES (0, 1.12345678919, 0.123456789012345678901234567890123456789, 0, 1.12345678919, 0.12345678901234567899),
+(0, 1.12345678914, 0.123456789012345678901234567890123456784, 0, 1.12345678914, 0.12345678901234567894),
+(0, 1.99999999999, 0.999999999999999999999999999999999999999, 0, 1.99999999999, 0.99999999999999999999),
+(0, 1.99999999994, 0.999999999999999999999999999999999999994, 0, 1.99999999994, 0.99999999999999999994),
+(0, -1.12345678919, -0.123456789012345678901234567890123456789, 0, -1.12345678919, -0.12345678901234567899),
+(0, -1.12345678914, -0.123456789012345678901234567890123456784, 0, -1.12345678914, -0.12345678901234567894),
+(0, -1.99999999999, -0.999999999999999999999999999999999999999, 0, -1.99999999999, -0.99999999999999999999),
+(0, -1.99999999994, -0.999999999999999999999999999999999999994, 0, -1.99999999994, -0.99999999999999999994);
+
+# insert values with leading zeros in the scale
+INSERT INTO cs1 VALUES (0, 1.0000000009, 0.00000000000000000000000000000000000009, 0, 1.0000000009, 0.0000000000000000009),
+(0, 1.00000000009, 0.000000000000000000000000000000000000009, 0, 1.00000000009, 0.00000000000000000009),
+(0, -1.0000000009, -0.00000000000000000000000000000000000009, 0, -1.0000000009, -0.0000000000000000009),
+(0, -1.00000000009, -0.000000000000000000000000000000000000009, 0, -1.00000000009, -0.00000000000000000009);
+
+# insert all zeros and nulls
+INSERT INTO cs1 VALUES (0, 0, 0, 0, 0, 0),
+(NULL, NULL, NULL, NULL, NULL, NULL);
+
+# insert values with digits interleaved with 0s
+INSERT INTO cs1 VALUES (12345678901234567890123456789000000001, 1234567890123456789012345678.0010000008, 0.00001000000000000000000000000000000009, 1234567890120000001, 123456789.0020000009, 0.0000000070000000009),
+(-12345678901234567890123456789000000001, -1234567890123456789012345678.0010000008, -0.00001000000000000000000000000000000009, -1234567890120000001, -123456789.0020000009, -0.0000000070000000009);
+
+SELECT "test2", d1, d2, d3, d4, d5, d6 FROM cs1;
+
+# INSERT ... SELECT
+INSERT INTO cs3 SELECT * FROM cs1;
+SELECT "insert_select_test1", d1, d2, d3, d4, d5, d6 FROM cs3;
+
+# LDI
+--exec rm -f /tmp/wide_decimal_ldi.txt
+SELECT * FROM cs3 INTO OUTFILE '/tmp/wide_decimal_ldi.txt' FIELDS TERMINATED BY ',';
+DELETE FROM cs3;
+LOAD DATA LOCAL INFILE '/tmp/wide_decimal_ldi.txt' INTO TABLE cs3 FIELDS TERMINATED BY ',';
+SELECT "ldi_test1", d1, d2, d3, d4, d5, d6 FROM cs3;
+
+# unsigned case. repeat queries for signed case here
+# single value inserts
+
+# simple inserts
+INSERT INTO cs2 VALUES (125, 1.25, 0.125, 125, 1.25, 0.125);
+INSERT INTO cs2 VALUES (-125, -1.25, -0.125, -125, -1.25, -0.125);
+INSERT INTO cs2 VALUES (1.25, 125, 125, 1.25, 125, 125);
+INSERT INTO cs2 VALUES (-1.25, -125, -125, -1.25, -125, -125);
+
+# insert maximum positive and negative values
+INSERT INTO cs2 values (99999999999999999999999999999999999998, 9999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998, 9999999999999999998, 999999999.9999999998, 0.9999999999999999998);
+INSERT INTO cs2 values (99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999, 9999999999999999999, 999999999.9999999999, 0.9999999999999999999);
+INSERT INTO cs2 values (-99999999999999999999999999999999999998, -9999999999999999999999999999.9999999998, -0.99999999999999999999999999999999999998, -9999999999999999998, -999999999.9999999998, -0.9999999999999999998);
+INSERT INTO cs2 values (-99999999999999999999999999999999999999, -9999999999999999999999999999.9999999999, -0.99999999999999999999999999999999999999, -9999999999999999999, -999999999.9999999999, -0.9999999999999999999);
+
+# check saturation of positive and negative values
+INSERT INTO cs2 VALUES (123456789012345678901234567890123456789, 12345678901234567890123456789.12345678912, 0.123456789012345678901234567890123456789, 12345678901234567890, 1234567890.12345678901, 0.12345678901234567891);
+INSERT INTO cs2 VALUES (-123456789012345678901234567890123456789, -12345678901234567890123456789.12345678912, -0.123456789012345678901234567890123456789, -12345678901234567890, -1234567890.12345678901, -0.12345678901234567891);
+
+# check rounding when scale > 0
+INSERT INTO cs2 VALUES (0, 1.12345678919, 0.123456789012345678901234567890123456789, 0, 1.12345678919, 0.12345678901234567899);
+INSERT INTO cs2 VALUES (0, 1.12345678914, 0.123456789012345678901234567890123456784, 0, 1.12345678914, 0.12345678901234567894);
+INSERT INTO cs2 VALUES (0, 1.99999999999, 0.999999999999999999999999999999999999999, 0, 1.99999999999, 0.99999999999999999999);
+INSERT INTO cs2 VALUES (0, 1.99999999994, 0.999999999999999999999999999999999999994, 0, 1.99999999994, 0.99999999999999999994);
+INSERT INTO cs2 VALUES (0, -1.12345678919, -0.123456789012345678901234567890123456789, 0, -1.12345678919, -0.12345678901234567899);
+INSERT INTO cs2 VALUES (0, -1.12345678914, -0.123456789012345678901234567890123456784, 0, -1.12345678914, -0.12345678901234567894);
+INSERT INTO cs2 VALUES (0, -1.99999999999, -0.999999999999999999999999999999999999999, 0, -1.99999999999, -0.99999999999999999999);
+INSERT INTO cs2 VALUES (0, -1.99999999994, -0.999999999999999999999999999999999999994, 0, -1.99999999994, -0.99999999999999999994);
+
+# insert values with leading zeros in the scale
+INSERT INTO cs2 VALUES (0, 1.0000000009, 0.00000000000000000000000000000000000009, 0, 1.0000000009, 0.0000000000000000009);
+INSERT INTO cs2 VALUES (0, 1.00000000009, 0.000000000000000000000000000000000000009, 0, 1.00000000009, 0.00000000000000000009);
+INSERT INTO cs2 VALUES (0, -1.0000000009, -0.00000000000000000000000000000000000009, 0, -1.0000000009, -0.0000000000000000009);
+INSERT INTO cs2 VALUES (0, -1.00000000009, -0.000000000000000000000000000000000000009, 0, -1.00000000009, -0.00000000000000000009);
+
+# insert all zeros
+INSERT INTO cs2 VALUES (0, 0, 0, 0, 0, 0);
+
+# insert all nulls
+INSERT INTO cs2 VALUES (NULL, NULL, NULL, NULL, NULL, NULL);
+INSERT INTO cs2 VALUES ();
+SELECT "test3", d1, d2, d3, d4, d5, d6 FROM cs2;
+
+# multi-value inserts. repeat queries for single-value inserts
+
+# simple inserts
+DROP TABLE IF EXISTS cs2;
+CREATE TABLE cs2 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED,
+                  d4 DECIMAL(19) UNSIGNED, d5 DECIMAL(19,10) UNSIGNED, d6 DECIMAL(19,19) UNSIGNED) ENGINE=columnstore;
+INSERT INTO cs2 VALUES (125, 1.25, 0.125, 125, 1.25, 0.125),
+(-125, -1.25, -0.125, -125, -1.25, -0.125),
+(1.25, 125, 125, 1.25, 125, 125),
+(-1.25, -125, -125, -1.25, -125, -125);
+
+# insert maximum positive and negative values
+INSERT INTO cs2 values (99999999999999999999999999999999999998, 9999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998, 9999999999999999998, 999999999.9999999998, 0.9999999999999999998),
+(99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999, 9999999999999999999, 999999999.9999999999, 0.9999999999999999999),
+(-99999999999999999999999999999999999998, -9999999999999999999999999999.9999999998, -0.99999999999999999999999999999999999998, -9999999999999999998, -999999999.9999999998, -0.9999999999999999998),
+(-99999999999999999999999999999999999999, -9999999999999999999999999999.9999999999, -0.99999999999999999999999999999999999999, -9999999999999999999, -999999999.9999999999, -0.9999999999999999999);
+
+# check saturation of positive and negative values
+INSERT INTO cs2 VALUES (123456789012345678901234567890123456789, 12345678901234567890123456789.12345678912, 0.123456789012345678901234567890123456789, 12345678901234567890, 1234567890.12345678901, 0.12345678901234567891),
+(-123456789012345678901234567890123456789, -12345678901234567890123456789.12345678912, -0.123456789012345678901234567890123456789, -12345678901234567890, -1234567890.12345678901, -0.12345678901234567891);
+
+# check rounding when scale > 0
+INSERT INTO cs2 VALUES (0, 1.12345678919, 0.123456789012345678901234567890123456789, 0, 1.12345678919, 0.12345678901234567899),
+(0, 1.12345678914, 0.123456789012345678901234567890123456784, 0, 1.12345678914, 0.12345678901234567894),
+(0, 1.99999999999, 0.999999999999999999999999999999999999999, 0, 1.99999999999, 0.99999999999999999999),
+(0, 1.99999999994, 0.999999999999999999999999999999999999994, 0, 1.99999999994, 0.99999999999999999994),
+(0, -1.12345678919, -0.123456789012345678901234567890123456789, 0, -1.12345678919, -0.12345678901234567899),
+(0, -1.12345678914, -0.123456789012345678901234567890123456784, 0, -1.12345678914, -0.12345678901234567894),
+(0, -1.99999999999, -0.999999999999999999999999999999999999999, 0, -1.99999999999, -0.99999999999999999999),
+(0, -1.99999999994, -0.999999999999999999999999999999999999994, 0, -1.99999999994, -0.99999999999999999994);
+
+# insert values with leading zeros in the scale
+INSERT INTO cs2 VALUES (0, 1.0000000009, 0.00000000000000000000000000000000000009, 0, 1.0000000009, 0.0000000000000000009),
+(0, 1.00000000009, 0.000000000000000000000000000000000000009, 0, 1.00000000009, 0.00000000000000000009),
+(0, -1.0000000009, -0.00000000000000000000000000000000000009, 0, -1.0000000009, -0.0000000000000000009),
+(0, -1.00000000009, -0.000000000000000000000000000000000000009, 0, -1.00000000009, -0.00000000000000000009);
+
+# insert all zeros and nulls
+INSERT INTO cs2 VALUES (0, 0, 0, 0, 0, 0),
+(NULL, NULL, NULL, NULL, NULL, NULL);
+
+# insert values with digits interleaved with 0s
+INSERT INTO cs2 VALUES (12345678901234567890123456789000000001, 1234567890123456789012345678.0010000008, 0.00001000000000000000000000000000000009, 1234567890120000001, 123456789.0020000009, 0.0000000070000000009),
+(-12345678901234567890123456789000000001, -1234567890123456789012345678.0010000008, -0.00001000000000000000000000000000000009, -1234567890120000001, -123456789.0020000009, -0.0000000070000000009);
+
+SELECT "test4", d1, d2, d3, d4, d5, d6 FROM cs2;
+
+# INSERT ... SELECT
+INSERT INTO cs4 SELECT * FROM cs2;
+SELECT "insert_select_test2", d1, d2, d3, d4, d5, d6 FROM cs4;
+
+# LDI
+--exec rm -f /tmp/wide_decimal_ldi.txt
+SELECT * FROM cs4 INTO OUTFILE '/tmp/wide_decimal_ldi.txt' FIELDS TERMINATED BY ',';
+DELETE FROM cs4;
+LOAD DATA LOCAL INFILE '/tmp/wide_decimal_ldi.txt' INTO TABLE cs4 FIELDS TERMINATED BY ',';
+SELECT "ldi_test2", d1, d2, d3, d4, d5, d6 FROM cs4;
+
+# Clean UP
+SET SQL_MODE=default;
+--exec rm -f /tmp/wide_decimal_ldi.txt
+DROP DATABASE mcol641_insert_db;
--- a/mysql-test/columnstore/basic/t/mcol641-joins.test
+++ b/mysql-test/columnstore/basic/t/mcol641-joins.test
@ -0,0 +1,45 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS mcol641_joins_db;
+--enable_warnings
+
+CREATE DATABASE mcol641_joins_db;
+USE mcol641_joins_db;
+
+--disable_query_log
+SET default_storage_engine=ColumnStore;
+--enable_query_log
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38)) ENGINE=columnstore;
+CREATE TABLE cs2 (de1 DECIMAL(38,38), de2 DECIMAL(38,10)) ENGINE=columnstore;
+
+INSERT INTO cs1 values (99999999999999999999999999999999999998, 9999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998);
+INSERT INTO cs1 VALUES (12345678901234567890123456789012345678, 1234567890123456789012345678.1234567890, 0.12345678901234567890123456789012345678);
+INSERT INTO cs1 VALUES (-12345678901234567890123456789012345678, -1234567890123456789012345678.1234567890, -0.12345678901234567890123456789012345678);
+INSERT INTO cs1 VALUES (0, 1.1234567891, 0.1234567890123456789012345678912345);
+
+INSERT INTO cs2 values (0.99999999999999999999999999999999999998, 9999999999999999999999999999.9999999998);
+INSERT INTO cs2 VALUES (0.12345678901234567890123456789012345678, 1234567890123456789012345678.0123456789);
+INSERT INTO cs2 VALUES (-0.12345678901234567890123456789012345678, -1234567890123456789012345678.0123456789);
+INSERT INTO cs2 VALUES (0.12345678901234567890123456789, 1.1234567891);
+
+SELECT cs1.d1, cs1.d2, cs2.de1 FROM cs1 INNER JOIN cs2 ON cs1.d2 = cs2.de2 ORDER BY 1;
+SELECT cs2.de1, cs1.d1, cs1.d2 FROM cs1 INNER JOIN cs2 ON cs1.d3 = cs2.de1 ORDER BY 1;
+
+SELECT cs2.de2, cs1.d1, cs1.d3, cs2.de1 FROM cs1 LEFT JOIN cs2 ON cs1.d2 = cs2.de2 ORDER BY 2;
+SELECT cs1.d3, cs1.d1, cs1.d2, cs2.de2 FROM cs1 LEFT JOIN cs2 ON cs1.d3 = cs2.de1 ORDER BY 1;
+
+SELECT cs1.d1, cs1.d3, cs2.de1, cs2.de2 FROM cs1 RIGHT JOIN cs2 ON cs1.d2 = cs2.de2 ORDER BY 3;
+SELECT cs2.de1, cs2.de2, cs1.d1, cs1.d2 FROM cs1 RIGHT JOIN cs2 ON cs1.d3 = cs2.de1 ORDER BY 1;
+
+SELECT * FROM cs1 WHERE cs1.d2 IN (SELECT cs2.de2 FROM cs2 WHERE cs2.de2 = cs1.d2) ORDER BY 1;
+SELECT * FROM cs2 WHERE cs2.de2 IN (SELECT cs1.d2 FROM cs1 WHERE cs1.d2 = cs2.de2) ORDER BY 1;
+SELECT * FROM cs1 WHERE cs1.d3 IN (SELECT cs2.de1 FROM cs2 WHERE cs2.de1 = cs1.d3) ORDER BY 1;
+SELECT * FROM cs2 WHERE cs2.de1 IN (SELECT cs1.d3 FROM cs1 WHERE cs1.d3 = cs2.de1) ORDER BY 1;
+
+SELECT count(*) FROM cs1 where exists (SELECT cs2.de2 FROM cs2 WHERE cs1.d2=cs2.de2);
+SELECT count(*) FROM cs2 where not exists (SELECT cs1.d2 FROM cs1 WHERE cs1.d2=cs2.de2);
+
+# Clean UP
+DROP DATABASE mcol641_joins_db;
--- a/mysql-test/columnstore/basic/t/mcol641-skewed-joins.test
+++ b/mysql-test/columnstore/basic/t/mcol641-skewed-joins.test
@ -0,0 +1,328 @@
+-- source ../include/have_columnstore.inc
+-- source ../include/enable_ordered_only.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS mcol641_joins_db;
+--enable_warnings
+
+CREATE DATABASE mcol641_joins_db;
+USE mcol641_joins_db;
+
+--disable_query_log
+SET default_storage_engine=ColumnStore;
+--enable_query_log
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(37), id TINYINT);
+CREATE TABLE cs2 (i1 SMALLINT, i2 MEDIUMINT, i3 INT, i4 BIGINT);
+
+INSERT INTO cs1 VALUES
+(99,0,1),
+(255,254,2),
+(254,253,3),
+(252,253,4),
+(65535,2147483647,5),
+(65534,2147483646,6),
+(65533,65532,7),
+(2147483647,2147483636,8),
+(2147483646,2147483635,9),
+(2147483645,2147483634,10),
+(2147483645,9223372036854775804,11),
+(9223372036854775807,0,12),
+(9223372036854775807,2147483627,13),
+(9223372036854775806,2147483626,14),
+(9223372036854775805,9223372036854775704,15);
+
+INSERT INTO cs2 VALUES
+(255,254,NULL,NULL),
+(254,253,NULL,NULL),
+(251,251,NULL,NULL),
+(NULL,65535,NULL,NULL),
+(NULL,65535,2147483647,NULL),
+(NULL,65534,2147483646,NULL),
+(NULL,0,2147483641,NULL),
+(NULL,NULL,2147483647,NULL),
+(NULL,NULL,2147483647,2147483636),
+(NULL,NULL,2147483646,2147483635),
+(NULL,NULL,0,2147483641),
+(NULL,NULL,NULL,9223372036854775807),
+(NULL,NULL,2147483627,9223372036854775807),
+(NULL,NULL,2147483626,9223372036854775806),
+(NULL,NULL,0,1);
+
+# Distributed PrimProc-based JOINs
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1 = cs2.i1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1 = cs2.i1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1 = cs2.i2 ORDER BY id,i3;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1 = cs2.i2 ORDER BY id,i3;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1 = cs2.i3 ORDER BY id,i2,i4;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1 = cs2.i3 ORDER BY id,i2,i4;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1 = cs2.i4 AND cs2.i3 IS NOT NULL ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1 = cs2.i4 AND cs2.i3 IS NOT NULL ORDER BY id;
+
+# PrimProc-based composite key JOINs
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1 = cs2.i1 AND cs1.d2 = cs2.i2 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1 = cs2.i1 AND cs1.d2 = cs2.i2 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1 = cs2.i2 AND cs1.d2 = cs2.i3 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1 = cs2.i2 AND cs1.d2 = cs2.i3 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1 = cs2.i3 AND cs1.d2 = cs2.i4 ORDER BY id,i2,i4;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1 = cs2.i3 AND cs1.d2 = cs2.i4 ORDER BY id,i2,i4;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1 = cs2.i4 AND cs1.d2 = cs2.i3 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1 = cs2.i4 AND cs1.d2 = cs2.i3 ORDER BY id;
+
+# ExeMgr-based JOINs
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 INNER JOIN (SELECT * FROM cs2)s2 ON s1.d1=s2.i1 ORDER BY id,i2;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 INNER JOIN (SELECT * FROM cs1)s1 ON s1.d1=s2.i1 ORDER BY id,i2;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 INNER JOIN (SELECT * FROM cs2)s2 ON s1.d1=s2.i2 ORDER BY id,i3;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 INNER JOIN (SELECT * FROM cs1)s1 ON s1.d1=s2.i2 ORDER BY id,i3;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 INNER JOIN (SELECT * FROM cs2)s2 ON s1.d1=s2.i3 ORDER BY id,i2,i4;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 INNER JOIN (SELECT * FROM cs1)s1 ON s1.d1=s2.i3 ORDER BY id,i2,i4;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 INNER JOIN (SELECT * FROM cs2)s2 ON s1.d1=s2.i4 AND s2.i3 IS NOT NULL ORDER BY id,i3;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 INNER JOIN (SELECT * FROM cs1)s1 ON s1.d1=s2.i4 AND s2.i3 IS NOT NULL ORDER BY id,i3;
+
+# Functional JOIN
+# Distributed PrimProc-based functional JOINs
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1-1 = cs2.i1-1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1-1 = cs2.i1-1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1-1 = cs2.i2-1 ORDER BY id,i3;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1-1 = cs2.i2-1 ORDER BY id,i3;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1-1 = cs2.i3-1 ORDER BY id,i2,i4;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1-1 = cs2.i3-1 ORDER BY id,i2,i4;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1-1 = cs2.i4-1 AND cs2.i3 IS NOT NULL ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1-1 = cs2.i4-1 AND cs2.i3 IS NOT NULL ORDER BY id;
+
+# PrimProc-based composite key JOINs
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1-1= cs2.i1-1 AND cs1.d2-1= cs2.i2-1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1-1= cs2.i1-1 AND cs1.d2-1= cs2.i2-1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1-1= cs2.i2-1 AND cs1.d2-1= cs2.i3-1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1-1= cs2.i2-1 AND cs1.d2-1= cs2.i3-1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1-1= cs2.i3-1 AND cs1.d2-1= cs2.i4-1 ORDER BY id,i2,i4;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1-1= cs2.i3-1 AND cs1.d2-1= cs2.i4-1 ORDER BY id,i2,i4;
+SELECT cs1.*, cs2.* FROM cs1 INNER JOIN cs2 ON cs1.d1-1= cs2.i4-1 AND cs1.d2-1= cs2.i3-1 ORDER BY id;
+SELECT cs1.*, cs2.* FROM cs2 INNER JOIN cs1 ON cs1.d1-1= cs2.i4-1 AND cs1.d2-1= cs2.i3-1 ORDER BY id;
+
+# ExeMgr-based JOINs
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 INNER JOIN (SELECT * FROM cs2)s2 ON s1.d1-1=s2.i1-1 ORDER BY id,i2;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 INNER JOIN (SELECT * FROM cs1)s1 ON s1.d1-1=s2.i1-1 ORDER BY id,i2;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 INNER JOIN (SELECT * FROM cs2)s2 ON s1.d1-1=s2.i2-1 ORDER BY id,i3;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 INNER JOIN (SELECT * FROM cs1)s1 ON s1.d1-1=s2.i2-1 ORDER BY id,i3;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 INNER JOIN (SELECT * FROM cs2)s2 ON s1.d1-1=s2.i3-1 ORDER BY id,i2,i4;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 INNER JOIN (SELECT * FROM cs1)s1 ON s1.d1-1=s2.i3-1 ORDER BY id,i2,i4;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 INNER JOIN (SELECT * FROM cs2)s2 ON s1.d1-1=s2.i4-1 AND s2.i3 IS NOT NULL ORDER BY id,i3;
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 INNER JOIN (SELECT * FROM cs1)s1 ON s1.d1-1=s2.i4-1 AND s2.i3 IS NOT NULL ORDER BY id,i3;
+
+-- source ../include/disable_ordered_only.inc
+
+# Skewed OUTER JOIN
+TRUNCATE cs1;
+TRUNCATE cs2;
+
+INSERT INTO cs1 VALUES
+(99,0,1),
+(255,254,2),
+(254,253,3),
+(252,253,4),
+(-252,253,5),
+(65535,2147483647,5),
+(65534,2147483646,6),
+(65533,65532,7),
+(2147483647,2147483636,8),
+(2147483646,2147483635,9),
+(2147483645,2147483634,10),
+(2147483645,9223372036854775804,11),
+(9223372036854775807,0,12),
+(9223372036854775807,2147483627,13),
+(9223372036854775806,2147483626,14),
+(9223372036854775805,9223372036854775704,15);
+
+INSERT INTO cs2 VALUES
+(255,254,NULL,NULL),
+(254,253,NULL,NULL),
+(251,251,NULL,NULL),
+(-252,253,NULL,NULL),
+(-250,253,NULL,NULL),
+(NULL,65535,NULL,NULL),
+(NULL,65535,2147483647,NULL),
+(NULL,65534,2147483646,NULL),
+(NULL,0,2147483641,NULL),
+(NULL,NULL,2147483647,NULL),
+(NULL,NULL,2147483647,2147483636),
+(NULL,NULL,2147483646,2147483635),
+(NULL,NULL,0,2147483641),
+(NULL,NULL,NULL,9223372036854775807),
+(NULL,NULL,2147483627,9223372036854775807),
+(NULL,NULL,2147483626,9223372036854775806),
+(NULL,NULL,0,1);
+
+# Distributed PrimProc-based JOINs
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1 = cs2.i1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1 = cs2.i1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1 = cs2.i2 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1 = cs2.i2 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1 = cs2.i3 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1 = cs2.i3 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1 = cs2.i4 AND cs2.i3 IS NOT NULL ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1 = cs2.i4 AND cs2.i3 IS NOT NULL ;
+
+# PrimProc-based composite key JOINs
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1 = cs2.i1 AND cs1.d2 = cs2.i2 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1 = cs2.i1 AND cs1.d2 = cs2.i2 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1 = cs2.i2 AND cs1.d2 = cs2.i3 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1 = cs2.i2 AND cs1.d2 = cs2.i3 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1 = cs2.i3 AND cs1.d2 = cs2.i4 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1 = cs2.i3 AND cs1.d2 = cs2.i4 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1 = cs2.i4 AND cs1.d2 = cs2.i3 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1 = cs2.i4 AND cs1.d2 = cs2.i3 ;
+
+# ExeMgr-based JOINs
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 LEFT JOIN (SELECT * FROM cs2)s2 ON s1.d1=s2.i1 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 LEFT JOIN (SELECT * FROM cs1)s1 ON s1.d1=s2.i1 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 LEFT JOIN (SELECT * FROM cs2)s2 ON s1.d1=s2.i2 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 LEFT JOIN (SELECT * FROM cs1)s1 ON s1.d1=s2.i2 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 LEFT JOIN (SELECT * FROM cs2)s2 ON s1.d1=s2.i3 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 LEFT JOIN (SELECT * FROM cs1)s1 ON s1.d1=s2.i3 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 LEFT JOIN (SELECT * FROM cs2)s2 ON s1.d1=s2.i4 AND s2.i3 IS NOT NULL ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 LEFT JOIN (SELECT * FROM cs1)s1 ON s1.d1=s2.i4 AND s2.i3 IS NOT NULL ;
+
+# Functional JOIN
+# Distributed PrimProc-based functional JOINs
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1-1 = cs2.i1-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1-1 = cs2.i1-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1-1 = cs2.i2-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1-1 = cs2.i2-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1-1 = cs2.i3-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1-1 = cs2.i3-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1-1 = cs2.i4-1 AND cs2.i3 IS NOT NULL ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1-1 = cs2.i4-1 AND cs2.i3 IS NOT NULL ;
+
+# PrimProc-based composite key JOINs
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1-1= cs2.i1-1 AND cs1.d2-1= cs2.i2-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1-1= cs2.i1-1 AND cs1.d2-1= cs2.i2-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1-1= cs2.i2-1 AND cs1.d2-1= cs2.i3-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1-1= cs2.i2-1 AND cs1.d2-1= cs2.i3-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1-1= cs2.i3-1 AND cs1.d2-1= cs2.i4-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1-1= cs2.i3-1 AND cs1.d2-1= cs2.i4-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs1 LEFT JOIN cs2 ON cs1.d1-1= cs2.i4-1 AND cs1.d2-1= cs2.i3-1 ;
+--sorted_result
+SELECT cs1.*, cs2.* FROM cs2 LEFT JOIN cs1 ON cs1.d1-1= cs2.i4-1 AND cs1.d2-1= cs2.i3-1 ;
+
+# ExeMgr-based JOINs
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 LEFT JOIN (SELECT * FROM cs2)s2 ON s1.d1-1=s2.i1-1 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 LEFT JOIN (SELECT * FROM cs1)s1 ON s1.d1-1=s2.i1-1 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 LEFT JOIN (SELECT * FROM cs2)s2 ON s1.d1-1=s2.i2-1 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 LEFT JOIN (SELECT * FROM cs1)s1 ON s1.d1-1=s2.i2-1 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 LEFT JOIN (SELECT * FROM cs2)s2 ON s1.d1-1=s2.i3-1 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 LEFT JOIN (SELECT * FROM cs1)s1 ON s1.d1-1=s2.i3-1 ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs1)s1 LEFT JOIN (SELECT * FROM cs2)s2 ON s1.d1-1=s2.i4-1 AND s2.i3 IS NOT NULL ;
+--sorted_result
+SELECT s1.*,s2.* FROM (SELECT * FROM cs2)s2 LEFT JOIN (SELECT * FROM cs1)s1 ON s1.d1-1=s2.i4-1 AND s2.i3 IS NOT NULL ;
+
+# Misc skewed JOIN
+
+CREATE TABLE t1 (a DECIMAL(10,1), b DECIMAL(20,1));
+INSERT INTO t1 VALUES (10.1,20.1);
+CREATE TABLE t2 (a DECIMAL(20,1), b DECIMAL(10,1));
+INSERT INTO t2 VALUES (10.1,20.1);
+SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b;
+
+DROP TABLE t1,t2;
+CREATE TABLE t1 (a CHAR(10), b DECIMAL(10,1));
+INSERT INTO t1 VALUES (10.1,20.1);
+CREATE TABLE t2 (a CHAR(10), b DECIMAL(20,1));
+INSERT INTO t2 VALUES (10.1,20.1);
+SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b;
+SELECT * FROM t2,t1 WHERE t1.a=t2.a AND t1.b=t2.b;
+
+DROP TABLE t1,t2;
+CREATE TABLE t1 (a DECIMAL(10,1), b CHAR(10));
+INSERT INTO t1 VALUES (10.1,20.1);
+CREATE TABLE t2 (a DECIMAL(20,1), b CHAR(10));
+INSERT INTO t2 VALUES (10.1,20.1);
+SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b;
+SELECT * FROM t2,t1 WHERE t1.a=t2.a AND t1.b=t2.b;
+
+SELECT * FROM t2,t1 WHERE (t1.a,t1.b)=(t2.a,t2.b);
+SELECT * FROM t1,t2 WHERE (t1.a,t1.b)=(t2.a,t2.b);
+
+SELECT * FROM t1 JOIN t2 USING (a,b);
+SELECT * FROM t2 JOIN t1 USING (a,b);
+
+# Testing the max number of skewed columns in a join.
+DROP TABLE t1,t2;
+CREATE TABLE t1 (a DECIMAL(10,1), b DECIMAL(20,1),a1 DECIMAL(10,1), b1 DECIMAL(20,1),a2 DECIMAL(10,1), b2 DECIMAL(20,1),a3 DECIMAL(10,1), b3 DECIMAL(20,1),a4 DECIMAL(10,1), b4 DECIMAL(20,1),a5 DECIMAL(10,1));
+INSERT INTO t1 VALUES (10.1,20.1,10.1,20.1,10.1,20.1,10.1,20.1,10.1,20.1,10.1);
+CREATE TABLE t2 (a DECIMAL(20,1), b DECIMAL(10,1),a1 DECIMAL(20,1), b1 DECIMAL(10,1),a2 DECIMAL(20,1), b2 DECIMAL(10,1),a3 DECIMAL(20,1), b3 DECIMAL(10,1),a4 DECIMAL(20,1), b4 DECIMAL(10,1),a5 DECIMAL(20,1));
+INSERT INTO t2 VALUES (10.1,20.1,10.1,20.1,10.1,20.1,10.1,20.1,10.1,20.1,10.1);
+# These work b/c the max is 10 columns.
+SELECT * FROM t1 INNER JOIN t2 USING(a,b,a1,b1,a2,b2,a3,b3,a4);
+SELECT * FROM t2 INNER JOIN t1 USING(a,b,a1,b1,a2,b2,a3,b3,a4);
+# These do not.
+#SELECT * FROM t1 INNER JOIN t2 USING(a,b,a1,b1,a2,b2,a3,b3,a4,b4,a5);
+#SELECT * FROM t1 INNER JOIN t2 USING(a,b,a1,b1,a2,b2,a3,b3,a4,b4,a5);
+
+# Mixing skewed columns with non-skewed.
+DROP TABLE t1,t2;
+CREATE TABLE t1 (a DECIMAL(10,1), t text, b DECIMAL(20,1), i1 int, a1 DECIMAL(10,1), b1 DECIMAL(20,1),a2 DECIMAL(10,1), b2 DECIMAL(20,1),a3 DECIMAL(10,1), b3 DECIMAL(20,1),a4 DECIMAL(10,1), b4 DECIMAL(20,1),a5 DECIMAL(10,1));
+INSERT INTO t1 VALUES (10.1,'some',20.1,42,10.1,20.1,10.1,20.1,10.1,20.1,10.1,20.1,10.1);
+CREATE TABLE t2 (a DECIMAL(20,1), b DECIMAL(10,1), t text, a1 DECIMAL(20,1), i1 int, b1 DECIMAL(10,1),a2 DECIMAL(20,1), b2 DECIMAL(10,1),a3 DECIMAL(20,1), b3 DECIMAL(10,1),a4 DECIMAL(20,1), b4 DECIMAL(10,1),a5 DECIMAL(20,1));
+INSERT INTO t2 VALUES (10.1,20.1,'some',10.1,42,20.1,10.1,20.1,10.1,20.1,10.1,20.1,10.1);
+
+# These work b/c the max is 10 columns.
+SELECT * FROM t1 INNER JOIN t2 USING(a,b,a1,b1,a2,b2,a3,b3,a4,b4,t,i1);
+SELECT * FROM t2 INNER JOIN t1 USING(a,b,a1,b1,a2,b2,a3,b3,a4,b4,t,i1);
+# These do not.
+#SELECT * FROM t1 INNER JOIN t2 USING(a,b,a1,b1,a2,b2,a3,b3,a4,b4,a5,t,i1);
+#SELECT * FROM t2 INNER JOIN t1 USING(a,b,a1,b1,a2,b2,a3,b3,a4,b4,a5,t,i1);
+
+SELECT t1.a,t1.t,t1.i1 FROM t1 INNER JOIN (SELECT * from t2) s1 USING(a,b);
+SELECT t2.a,t2.t,s1.i1 FROM t2 INNER JOIN (SELECT * from t1) s1 USING(a,b);
+SELECT t1.a,t1.t,t1.i1 FROM t1 INNER JOIN (SELECT * from t2) s1 where t1.a+1=s1.a+1 and t1.b+1=s1.b+1;
+SELECT t2.a,t2.t,t2.i1 FROM t2 INNER JOIN (SELECT * from t1) s1 where t2.a+1=s1.a+1 and t2.b+1=s1.b+1;
+
+# Clean UP
+DROP DATABASE mcol641_joins_db;
--- a/mysql-test/columnstore/basic/t/mcol641-sorting.test
+++ b/mysql-test/columnstore/basic/t/mcol641-sorting.test
@ -0,0 +1,90 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS mcol641_sorting_db;
+--enable_warnings
+
+CREATE DATABASE mcol641_sorting_db;
+USE mcol641_sorting_db;
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38), d4 DECIMAL(38),d5 DECIMAL(38),i1 INT) ENGINE=columnstore;
+CREATE TABLE cs2 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED, d4 DECIMAL(38),d5 DECIMAL(38),i1 INT) ENGINE=columnstore;
+
+INSERT INTO cs1 VALUES
+    (1234,5678,-0.12345678901234567890123456789018,2,1,1),     
+    (1234,-5678,0.1234567890123456789012345,2,1,1),
+    (12345678901234567890123,1234567890123456789012.9012345678,0.123456789012345678901234567890,2,1,1),
+    (NULL,NULL,NULL,2,1,1),
+    (0,0,0,2,1,1),
+    (1234,5678,0.1234567890123456783456789012345678,3,2,2),
+    (-123456789123456789,-5678,0.123456789012345673456789012345678,3,2,2),
+    (12345678901234567890901,1234567890123478901234.9012345678,0.1234567890123456789012345678908,3,2,2),
+    (NULL,NULL,NULL,3,2,2),
+    (0,0,0,3,2,2),
+    (1234,5678,-0.12345678901234567890123456789018,11111111111111111111111111111111,1,1),
+    (1234,5678,-0.12345678901234567890123456789018,11111111111111111111111111111111,1,1),
+    (1234,5678,-0.12345678901234567890123456789018,11111111111111111111111111111112,1,1); 
+
+INSERT INTO cs2 VALUES
+    (1234,5678,0.12345678901234567890123456789018,2,1,1),     
+    (1234,5678,0.1234567890123456789012345,2,1,1),
+    (12345678901234567890123,1234567890123456789012.9012345678,0.123456789012345678901234567890,2,1,1),
+    (NULL,NULL,NULL,2,1,1),
+    (0,0,0,2,1,1),
+    (1234,5678,0.1234567890123456783456789012345678,3,2,2),
+    (123456789123456789,5678,0.123456789012345673456789012345678,3,2,2),
+    (12345678901234567890901,1234567890123478901234.9012345678,0.1234567890123456789012345678908,3,2,2),
+    (NULL,NULL,NULL,3,2,2),
+    (0,0,0,3,2,2),
+    (1234,5678,0.12345678901234567890123456789018,11111111111111111111111111111111,1,1),
+    (1234,5678,0.12345678901234567890123456789018,11111111111111111111111111111111,1,1),
+    (1234,5678,0.12345678901234567890123456789018,11111111111111111111111111111112,1,1); 
+
+# ORDER BY
+SELECT 't1_q1',d1,d5 FROM cs1 ORDER BY d1,d5;
+SELECT 't1_q2',d2,d5 FROM cs1 ORDER BY d2,d5;
+SELECT 't1_q3',d3,d5 FROM cs1 ORDER BY d3,d5;
+
+# LIMIT
+SELECT 't2_q1',d1,d5 FROM cs1 ORDER BY d1,d5 LIMIT 1 OFFSET 2;
+SELECT 't2_q2',d2,d5 FROM cs1 ORDER BY d2,d5 LIMIT 1 OFFSET 2;
+SELECT 't2_q3',d3,d5 FROM cs1 ORDER BY d3,d5 LIMIT 1 OFFSET 2;
+
+# DISTINCT
+SELECT DISTINCT 't3_q1',d1,d5 FROM cs1 ORDER BY d1,d5;
+SELECT DISTINCT 't3_q2',d2,d5 FROM cs1 ORDER BY d2,d5;
+SELECT DISTINCT 't3_q3',d3,d5 FROM cs1 ORDER BY d3,d5;
+
+# ORDER BY
+SELECT 't4_q1',d1,d5 FROM cs1 ORDER BY d1,d5 ASC;
+SELECT 't4_q2',d2,d5 FROM cs1 ORDER BY d2,d5 ASC;
+SELECT 't4_q3',d3,d5 FROM cs1 ORDER BY d3,d5 ASC;
+SELECT 't4_q1',d1,d5 FROM cs1 ORDER BY d1,d5 DESC;
+SELECT 't4_q2',d2,d5 FROM cs1 ORDER BY d2,d5 DESC;
+SELECT 't4_q3',d3,d5 FROM cs1 ORDER BY d3,d5 DESC;
+
+# ORDER BY
+SELECT 't5_q1',d1,d5 FROM cs2 ORDER BY d1,d5;
+SELECT 't5_q2',d2,d5 FROM cs2 ORDER BY d2,d5;
+SELECT 't5_q3',d3,d5 FROM cs2 ORDER BY d3,d5;
+
+# LIMIT
+SELECT 't6_q1',d1,d5 FROM cs2 ORDER BY d1,d5 LIMIT 1 OFFSET 2;
+SELECT 't6_q2',d2,d5 FROM cs2 ORDER BY d2,d5 LIMIT 1 OFFSET 2;
+SELECT 't6_q3',d3,d5 FROM cs2 ORDER BY d3,d5 LIMIT 1 OFFSET 2;
+
+# DISTINCT
+SELECT DISTINCT 't7_q1',d1,d5 FROM cs2 ORDER BY d1,d5;
+SELECT DISTINCT 't7_q2',d2,d5 FROM cs2 ORDER BY d2,d5;
+SELECT DISTINCT 't7_q3',d3,d5 FROM cs2 ORDER BY d3,d5;
+
+# ORDER BY
+SELECT 't8_q1',d1,d5 FROM cs2 ORDER BY d1,d5 ASC;
+SELECT 't8_q2',d2,d5 FROM cs2 ORDER BY d2,d5 ASC;
+SELECT 't8_q3',d3,d5 FROM cs2 ORDER BY d3,d5 ASC;
+SELECT 't8_q1',d1,d5 FROM cs2 ORDER BY d1,d5 DESC;
+SELECT 't8_q2',d2,d5 FROM cs2 ORDER BY d2,d5 DESC;
+SELECT 't8_q3',d3,d5 FROM cs2 ORDER BY d3,d5 DESC;
+
+# Clean UP
+DROP DATABASE mcol641_sorting_db;
--- a/mysql-test/columnstore/basic/t/mcol641-union.test
+++ b/mysql-test/columnstore/basic/t/mcol641-union.test
@ -0,0 +1,35 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS mcol641_union_db;
+--enable_warnings
+
+CREATE DATABASE mcol641_union_db;
+USE mcol641_union_db;
+
+SET SQL_MODE='ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION';
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(38,10), d3 DECIMAL(38,38)) ENGINE=columnstore;
+CREATE TABLE cs2 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(38,10) UNSIGNED, d3 DECIMAL(38,38) UNSIGNED) ENGINE=columnstore;
+
+INSERT INTO cs1 VALUES (125, 1.25, 0.125);
+INSERT INTO cs1 VALUES (-125, -1.25, -0.125);
+INSERT INTO cs1 values (99999999999999999999999999999999999998, 9999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998);
+INSERT INTO cs1 values (99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999);
+INSERT INTO cs1 values (-99999999999999999999999999999999999998, -9999999999999999999999999999.9999999998, -0.99999999999999999999999999999999999998);
+INSERT INTO cs1 values (-99999999999999999999999999999999999999, -9999999999999999999999999999.9999999999, -0.99999999999999999999999999999999999999);
+
+SELECT d1, d1, d2 FROM cs1 UNION SELECT d2, d3, d3 FROM cs1;
+SELECT d2, d3, d3 FROM cs1 UNION SELECT d1, d1, d2 FROM cs1;
+SELECT d1, d2, d3 FROM cs1 UNION SELECT d1, d2, d3 FROM cs1;
+
+INSERT INTO cs2 VALUES (125, 1.25, 0.125);
+INSERT INTO cs2 values (99999999999999999999999999999999999998, 9999999999999999999999999999.9999999998, 0.99999999999999999999999999999999999998);
+INSERT INTO cs2 values (99999999999999999999999999999999999999, 9999999999999999999999999999.9999999999, 0.99999999999999999999999999999999999999);
+
+SELECT d1, d1, d2 FROM cs2 UNION SELECT d2, d3, d3 FROM cs2;
+SELECT d2, d3, d3 FROM cs2 UNION SELECT d1, d1, d2 FROM cs2;
+SELECT d1, d2, d3 FROM cs2 UNION SELECT d1, d2, d3 FROM cs2;
+
+# Clean UP
+DROP DATABASE mcol641_union_db;
--- a/mysql-test/columnstore/basic/t/mcol641-update.test
+++ b/mysql-test/columnstore/basic/t/mcol641-update.test
@ -0,0 +1,357 @@
+-- source ../include/have_columnstore.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS mcol641_update_db;
+--enable_warnings
+
+CREATE DATABASE mcol641_update_db;
+USE mcol641_update_db;
+
+DROP PROCEDURE IF EXISTS signedinsertproc;
+DROP PROCEDURE IF EXISTS signeddeleteproc;
+DROP PROCEDURE IF EXISTS unsignedinsertproc;
+DROP PROCEDURE IF EXISTS unsigneddeleteproc;
+
+DELIMITER //;
+
+CREATE PROCEDURE signedinsertproc ()
+ BEGIN
+  INSERT INTO cs1 VALUES (125, 125);
+  INSERT INTO cs1 VALUES (-125, -125);
+  INSERT INTO cs1 values (99999999999999999999999999999999999998, 9999999999999999998);
+  INSERT INTO cs1 values (99999999999999999999999999999999999999, 9999999999999999999);
+  INSERT INTO cs1 values (-99999999999999999999999999999999999998, -9999999999999999998);
+  INSERT INTO cs1 values (-99999999999999999999999999999999999999, -9999999999999999999);
+  INSERT INTO cs1 VALUES (0, 0);
+  INSERT INTO cs1 VALUES (NULL, NULL);
+  
+  INSERT INTO cs2 VALUES (1.25, 1.25);
+  INSERT INTO cs2 VALUES (-1.25, -1.25);
+  INSERT INTO cs2 values (9999999999999999999999999999.9999999998, 999999999.9999999998);
+  INSERT INTO cs2 values (9999999999999999999999999999.9999999999, 999999999.9999999999);
+  INSERT INTO cs2 values (-9999999999999999999999999999.9999999998, -999999999.9999999998);
+  INSERT INTO cs2 values (-9999999999999999999999999999.9999999999, -999999999.9999999999);
+  INSERT INTO cs2 VALUES (1.1234567891, 1.1234567891);
+  INSERT INTO cs2 VALUES (1.9999999999, 1.9999999999);
+  INSERT INTO cs2 VALUES (-1.1234567891, -1.1234567891);
+  INSERT INTO cs2 VALUES (-1.9999999999, -1.9999999999);
+  INSERT INTO cs2 VALUES (1.0000000009, 1.0000000009);
+  INSERT INTO cs2 VALUES (-1.0000000009, -1.0000000009);
+  INSERT INTO cs2 VALUES (0, 0);
+  INSERT INTO cs2 VALUES (NULL, NULL);
+  
+  INSERT INTO cs3 VALUES (0.125, 0.125);
+  INSERT INTO cs3 VALUES (-0.125, -0.125);
+  INSERT INTO cs3 values (0.99999999999999999999999999999999999998, 0.9999999999999999998);
+  INSERT INTO cs3 values (0.99999999999999999999999999999999999999, 0.9999999999999999999);
+  INSERT INTO cs3 values (-0.99999999999999999999999999999999999998, -0.9999999999999999998);
+  INSERT INTO cs3 values (-0.99999999999999999999999999999999999999, -0.9999999999999999999);
+  INSERT INTO cs3 VALUES (0.12345678901234567890123456789012345678, 0.1234567890123456789);
+  INSERT INTO cs3 VALUES (0.19999999999999999999999999999999999999, 0.1999999999999999999);
+  INSERT INTO cs3 VALUES (-0.12345678901234567890123456789012345678, -0.1234567890123456789);
+  INSERT INTO cs3 VALUES (-0.19999999999999999999999999999999999999, -0.1999999999999999999);
+  INSERT INTO cs3 VALUES (0.00000000000000000000000000000000000009, 0.0000000000000000009);
+  INSERT INTO cs3 VALUES (-0.00000000000000000000000000000000000009, -0.0000000000000000009);
+  INSERT INTO cs3 VALUES (0, 0);
+  INSERT INTO cs3 VALUES (NULL, NULL);
+ END//
+
+CREATE PROCEDURE unsignedinsertproc ()
+ BEGIN
+  INSERT INTO cs4 VALUES (125, 125);
+  INSERT INTO cs4 values (99999999999999999999999999999999999998, 9999999999999999998);
+  INSERT INTO cs4 values (99999999999999999999999999999999999999, 9999999999999999999);
+  INSERT INTO cs4 VALUES (0, 0);
+  INSERT INTO cs4 VALUES (NULL, NULL);
+
+  INSERT INTO cs5 VALUES (1.25, 1.25);
+  INSERT INTO cs5 values (9999999999999999999999999999.9999999998, 999999999.9999999998);
+  INSERT INTO cs5 values (9999999999999999999999999999.9999999999, 999999999.9999999999);
+  INSERT INTO cs5 VALUES (1.1234567891, 1.1234567891);
+  INSERT INTO cs5 VALUES (1.9999999999, 1.9999999999);
+  INSERT INTO cs5 VALUES (1.0000000009, 1.0000000009);
+  INSERT INTO cs5 VALUES (0, 0);
+  INSERT INTO cs5 VALUES (NULL, NULL);
+
+  INSERT INTO cs6 VALUES (0.125, 0.125);
+  INSERT INTO cs6 values (0.99999999999999999999999999999999999998, 0.9999999999999999998);
+  INSERT INTO cs6 values (0.99999999999999999999999999999999999999, 0.9999999999999999999);
+  INSERT INTO cs6 VALUES (0.12345678901234567890123456789012345678, 0.1234567890123456789);
+  INSERT INTO cs6 VALUES (0.19999999999999999999999999999999999999, 0.1999999999999999999);
+  INSERT INTO cs6 VALUES (0.00000000000000000000000000000000000009, 0.0000000000000000009);
+  INSERT INTO cs6 VALUES (0, 0);
+  INSERT INTO cs6 VALUES (NULL, NULL);
+ END//
+
+CREATE PROCEDURE signeddeleteproc ()
+ BEGIN
+  DELETE FROM cs1;
+  DELETE FROM cs2;
+  DELETE FROM cs3;
+ END//
+
+CREATE PROCEDURE unsigneddeleteproc ()
+ BEGIN
+  DELETE FROM cs4;
+  DELETE FROM cs5;
+  DELETE FROM cs6;
+ END//
+
+DELIMITER ;//
+
+DROP TABLE IF EXISTS cs1;
+DROP TABLE IF EXISTS cs2;
+DROP TABLE IF EXISTS cs3;
+DROP TABLE IF EXISTS cs4;
+DROP TABLE IF EXISTS cs5;
+DROP TABLE IF EXISTS cs6;
+
+CREATE TABLE cs1 (d1 DECIMAL(38), d2 DECIMAL(19)) ENGINE=columnstore;
+CREATE TABLE cs2 (d1 DECIMAL(38,10), d2 DECIMAL(19,10)) ENGINE=columnstore;
+CREATE TABLE cs3 (d1 DECIMAL(38,38), d2 DECIMAL(19,19)) ENGINE=columnstore;
+CREATE TABLE cs4 (d1 DECIMAL(38) UNSIGNED, d2 DECIMAL(19) UNSIGNED) ENGINE=columnstore;
+CREATE TABLE cs5 (d1 DECIMAL(38,10) UNSIGNED, d2 DECIMAL(19,10) UNSIGNED) ENGINE=columnstore;
+CREATE TABLE cs6 (d1 DECIMAL(38,38) UNSIGNED, d2 DECIMAL(19,19) UNSIGNED) ENGINE=columnstore;
+
+CALL signedinsertproc();
+
+# Updates with constant values without a WHERE clause
+UPDATE cs1 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789;
+UPDATE cs2 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789;
+UPDATE cs3 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789;
+SELECT "signedtest1", d1, d2 FROM cs1;
+SELECT "signedtest1", d1, d2 FROM cs2;
+SELECT "signedtest1", d1, d2 FROM cs3;
+
+# Updates with WHERE clause
+# Update a single row with a constant value in WHERE clause
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=12345678901234567890123456789012345678, d2=0 WHERE d1=-99999999999999999999999999999999999998;
+UPDATE cs1 SET d1=0, d2=123456789012345678 WHERE d2=9999999999999999999;
+UPDATE cs2 SET d1=1234567890123456789012345678.9012345678, d2=0 WHERE d1=-9999999999999999999999999999.9999999998;
+UPDATE cs2 SET d1=0, d2=123456789.012345678 WHERE d2=999999999.9999999999;
+UPDATE cs3 SET d1=0.12345678901234567890123456789012345678, d2=0 WHERE d1=-0.99999999999999999999999999999999999998;
+UPDATE cs3 SET d1=0, d2=0.123456789012345678 WHERE d2=0.9999999999999999999;
+SELECT "signedtest2", d1, d2 FROM cs1;
+SELECT "signedtest2", d1, d2 FROM cs2;
+SELECT "signedtest2", d1, d2 FROM cs3;
+
+# Update multiple rows
+# Updates with multiple constant values in WHERE clause
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 in (-99999999999999999999999999999999999998, 99999999999999999999999999999999999999);
+UPDATE cs2 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 in (-9999999999999999999999999999.9999999998, 9999999999999999999999999999.9999999999);
+UPDATE cs3 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 in (-0.99999999999999999999999999999999999998, 0.99999999999999999999999999999999999999);
+SELECT "signedtest3", d1, d2 FROM cs1;
+SELECT "signedtest3", d1, d2 FROM cs2;
+SELECT "signedtest3", d1, d2 FROM cs3;
+
+# Updates with comparison operators in WHERE clause
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 < -99999999999999999999999999999999999998 OR d2 > 9999999999999999998;
+UPDATE cs2 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 < -9999999999999999999999999999.9999999998 OR d2 > 999999999.9999999998;
+UPDATE cs3 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 < -0.99999999999999999999999999999999999998 OR d2 > 0.9999999999999999998;
+SELECT "signedtest4a", d1, d2 FROM cs1;
+SELECT "signedtest4a", d1, d2 FROM cs2;
+SELECT "signedtest4a", d1, d2 FROM cs3;
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 <= -99999999999999999999999999999999999998 OR d2 >= 9999999999999999998;
+UPDATE cs2 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 <= -9999999999999999999999999999.9999999998 OR d2 >= 999999999.9999999998;
+UPDATE cs3 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 <= -0.99999999999999999999999999999999999998 OR d2 >= 0.9999999999999999998;
+SELECT "signedtest4b", d1, d2 FROM cs1;
+SELECT "signedtest4b", d1, d2 FROM cs2;
+SELECT "signedtest4b", d1, d2 FROM cs3;
+
+# Update with NULL in the WHERE clause
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 is NULL;
+UPDATE cs2 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 is NULL;
+UPDATE cs3 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 is NULL;
+SELECT "signedtest5", d1, d2 FROM cs1;
+SELECT "signedtest5", d1, d2 FROM cs2;
+SELECT "signedtest5", d1, d2 FROM cs3;
+
+# Update with != operator
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 != 125;
+UPDATE cs2 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 != 1.25;
+UPDATE cs3 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 != 0.125;
+SELECT "signedtest6", d1, d2 FROM cs1;
+SELECT "signedtest6", d1, d2 FROM cs2;
+SELECT "signedtest6", d1, d2 FROM cs3;
+
+# Update with non-constant value in the WHERE clause
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d2=d1 WHERE d1 = d2;
+UPDATE cs2 SET d2=d1 WHERE d1 = d2;
+UPDATE cs3 SET d2=d1 WHERE d1 = d2;
+SELECT "signedtest7", d1, d2 FROM cs1;
+SELECT "signedtest7", d1, d2 FROM cs2;
+SELECT "signedtest7", d1, d2 FROM cs3;
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=d2 WHERE d1 != d2;
+UPDATE cs2 SET d1=d2 WHERE d1 != d2;
+UPDATE cs3 SET d1=d2 WHERE d1 != d2;
+SELECT "signedtest8", d1, d2 FROM cs1;
+SELECT "signedtest8", d1, d2 FROM cs2;
+SELECT "signedtest8", d1, d2 FROM cs3;
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 < d2;
+UPDATE cs2 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 < d2;
+UPDATE cs3 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 < d2;
+SELECT "signedtest9", d1, d2 FROM cs1;
+SELECT "signedtest9", d1, d2 FROM cs2;
+SELECT "signedtest9", d1, d2 FROM cs3;
+CALL signeddeleteproc();
+CALL signedinsertproc();
+UPDATE cs1 SET d1=d2 WHERE d1 > d2;
+UPDATE cs2 SET d1=d2 WHERE d1 > d2;
+UPDATE cs3 SET d1=d2 WHERE d1 > d2;
+SELECT "signedtest10", d1, d2 FROM cs1;
+SELECT "signedtest10", d1, d2 FROM cs2;
+SELECT "signedtest10", d1, d2 FROM cs3;
+
+# Updates with functions and expressions in the WHERE clause
+
+
+# Repeat above tests for the unsigned case
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+
+# Updates with constant values without a WHERE clause
+UPDATE cs4 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789;
+UPDATE cs5 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789;
+UPDATE cs6 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789;
+SELECT "unsignedtest1", d1, d2 FROM cs4;
+SELECT "unsignedtest1", d1, d2 FROM cs5;
+SELECT "unsignedtest1", d1, d2 FROM cs6;
+
+#
+# Updates with WHERE clause
+#
+# Update a single row with a constant value in WHERE clause
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=12345678901234567890123456789012345678, d2=0 WHERE d1=99999999999999999999999999999999999998;
+UPDATE cs4 SET d1=0, d2=123456789012345678 WHERE d2=9999999999999999999;
+UPDATE cs5 SET d1=1234567890123456789012345678.9012345678, d2=0 WHERE d1=9999999999999999999999999999.9999999998;
+UPDATE cs5 SET d1=0, d2=123456789.012345678 WHERE d2=999999999.9999999999;
+UPDATE cs6 SET d1=0.12345678901234567890123456789012345678, d2=0 WHERE d1=0.99999999999999999999999999999999999998;
+UPDATE cs6 SET d1=0, d2=0.123456789012345678 WHERE d2=0.9999999999999999999;
+SELECT "unsignedtest2", d1, d2 FROM cs4;
+SELECT "unsignedtest2", d1, d2 FROM cs5;
+SELECT "unsignedtest2", d1, d2 FROM cs6;
+
+# Update multiple rows
+# Updates with multiple constant values in WHERE clause
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 in (99999999999999999999999999999999999998, 99999999999999999999999999999999999999);
+UPDATE cs5 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 in (9999999999999999999999999999.9999999998, 9999999999999999999999999999.9999999999);
+UPDATE cs6 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 in (0.99999999999999999999999999999999999998, 0.99999999999999999999999999999999999999);
+SELECT "unsignedtest3", d1, d2 FROM cs4;
+SELECT "unsignedtest3", d1, d2 FROM cs5;
+SELECT "unsignedtest3", d1, d2 FROM cs6;
+
+#
+# Updates with comparison operators in WHERE clause
+#
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 > 99999999999999999999999999999999999998 OR d2 > 9999999999999999998;
+UPDATE cs5 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 > 9999999999999999999999999999.9999999998 OR d2 > 999999999.9999999998;
+UPDATE cs6 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 > 0.99999999999999999999999999999999999998 OR d2 > 0.9999999999999999998;
+SELECT "unsignedtest4a", d1, d2 FROM cs4;
+SELECT "unsignedtest4a", d1, d2 FROM cs5;
+SELECT "unsignedtest4a", d1, d2 FROM cs6;
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 >= 99999999999999999999999999999999999998 OR d2 >= 9999999999999999998;
+UPDATE cs5 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 >= 9999999999999999999999999999.9999999998 OR d2 >= 999999999.9999999998;
+UPDATE cs6 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 >= 0.99999999999999999999999999999999999998 OR d2 >= 0.9999999999999999998;
+SELECT "unsignedtest4b", d1, d2 FROM cs4;
+SELECT "unsignedtest4b", d1, d2 FROM cs5;
+SELECT "unsignedtest4b", d1, d2 FROM cs6;
+
+# Update with NULL in the WHERE clause
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 is NULL;
+UPDATE cs5 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 is NULL;
+UPDATE cs6 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 is NULL;
+SELECT "unsignedtest5", d1, d2 FROM cs4;
+SELECT "unsignedtest5", d1, d2 FROM cs5;
+SELECT "unsignedtest5", d1, d2 FROM cs6;
+
+# Update with != operator
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 != 125;
+UPDATE cs5 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 != 1.25;
+UPDATE cs6 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 != 0.125;
+SELECT "unsignedtest6", d1, d2 FROM cs4;
+SELECT "unsignedtest6", d1, d2 FROM cs5;
+SELECT "unsignedtest6", d1, d2 FROM cs6;
+
+# Update with non-constant value in the WHERE clause
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d2=d1 WHERE d1 = d2;
+UPDATE cs5 SET d2=d1 WHERE d1 = d2;
+UPDATE cs6 SET d2=d1 WHERE d1 = d2;
+SELECT "unsignedtest7", d1, d2 FROM cs4;
+SELECT "unsignedtest7", d1, d2 FROM cs5;
+SELECT "unsignedtest7", d1, d2 FROM cs6;
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=d2 WHERE d1 != d2;
+UPDATE cs5 SET d1=d2 WHERE d1 != d2;
+UPDATE cs6 SET d1=d2 WHERE d1 != d2;
+SELECT "unsignedtest8", d1, d2 FROM cs4;
+SELECT "unsignedtest8", d1, d2 FROM cs5;
+SELECT "unsignedtest8", d1, d2 FROM cs6;
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=12345678901234567890123456789012345678, d2=1234567890123456789 WHERE d1 < d2;
+UPDATE cs5 SET d1=1234567890123456789012345678.9012345678, d2=123456789.0123456789 WHERE d1 < d2;
+UPDATE cs6 SET d1=0.12345678901234567890123456789012345678, d2=0.1234567890123456789 WHERE d1 < d2;
+SELECT "unsignedtest9", d1, d2 FROM cs4;
+SELECT "unsignedtest9", d1, d2 FROM cs5;
+SELECT "unsignedtest9", d1, d2 FROM cs6;
+CALL unsigneddeleteproc();
+CALL unsignedinsertproc();
+UPDATE cs4 SET d1=d2 WHERE d1 > d2;
+UPDATE cs5 SET d1=d2 WHERE d1 > d2;
+UPDATE cs6 SET d1=d2 WHERE d1 > d2;
+SELECT "unsignedtest10a", d1, d2 FROM cs4;
+SELECT "unsignedtest10a", d1, d2 FROM cs5;
+SELECT "unsignedtest10a", d1, d2 FROM cs6;
+
+# Following test fails due to MCOL-3892
+# Uncomment the test when the issue is fixed.
+#CALL unsigneddeleteproc();
+#CALL unsignedinsertproc();
+#UPDATE cs4 SET d2=d1 WHERE d1 < d2;
+#UPDATE cs5 SET d2=d1 WHERE d1 < d2;
+#UPDATE cs6 SET d2=d1 WHERE d1 < d2;
+#SELECT "unsignedtest10b", d1, d2 FROM cs4;
+#SELECT "unsignedtest10b", d1, d2 FROM cs5;
+#SELECT "unsignedtest10b", d1, d2 FROM cs6;
+
+# Updates with functions and expressions in the WHERE clause
+
+# Clean UP
+DROP PROCEDURE IF EXISTS signedinsertproc;
+DROP PROCEDURE IF EXISTS signeddeleteproc;
+DROP PROCEDURE IF EXISTS unsignedinsertproc;
+DROP PROCEDURE IF EXISTS unsigneddeleteproc;
+DROP DATABASE mcol641_update_db;