MDEV-32854: Make JSON_DEPTH_LIMIT unlimited

This patch is the columnstore-part of the task. Columnstore wanted to have
previous 32 depth, so this patch aims at keeping the compatibility.

mysql-test/columnstore/basic/r/func_json_array_append.result

@@ -5,35 +5,16 @@ USE json_array_append_db;
 # Test of JSON_ARRAY_APPEND function.
 # ----------------------------------------------------------------------
 CREATE TABLE t1(a TEXT, p TEXT, v TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t1
-VALUES
-('[1,2,3]', '$[0]', 2),
-('[1,2,3]', '$[0]', 1.2),
-('[1,2,3]', '$[0]', 'key1'),
-('[1,2,3]', '$[0]', TRUE),
-('[1,2,3]', '$[0]', false),
-('[1,2,3]', '$[0]', NULL),
-(
-'{"a": "foo", "b": "bar", "c": "wibble" }',
-'$.b',
-4
-),
-(
-'{"a": "foo", "b": "bar", "c": "wibble" }',
-'$.c',
-'grape'
-    ),
-(
-'{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}',
-'$.b',
-4
-),
-(
-'{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}',
-'$.c',
-'grape'
-    );
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 2);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 1.2);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 'key1');
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', TRUE);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', false);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', NULL);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": "bar", "c": "wibble" }', '$.b', 4);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": "bar", "c": "wibble" }', '$.c', 'grape');
+INSERT INTO t1 VALUES ('{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}', '$.b', 4);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}', '$.c', 'grape');
 SELECT
 a AS arrary,
 p AS path,
@@ -54,10 +35,7 @@ arrary	path	value	result
 {"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}	$.c	grape	{"a": "foo", "b": [1, 2, 3], "c": ["apple", "pear", "grape"]}
 # NULL args
 CREATE TABLE t2(a TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t2
-VALUES
-('[1,2,3]');
+INSERT INTO t2 VALUES ('[1,2,3]');
 SELECT
 JSON_ARRAY_APPEND(a, NULL, JSON_COMPACT(1)),
 JSON_ARRAY_APPEND(a, '$', NULL)
@@ -66,10 +44,7 @@ t2;
 JSON_ARRAY_APPEND(a, NULL, JSON_COMPACT(1))	JSON_ARRAY_APPEND(a, '$', NULL)
 NULL	[1, 2, 3, null]
 TRUNCATE t2;
-INSERT INTO
-t2
-VALUES
-('$.b');
+INSERT INTO t2 VALUES ('$.b');
 SELECT
 JSON_ARRAY_APPEND(NULL, a, JSON_COMPACT(1)),
 JSON_ARRAY_APPEND('[1,2,3]', a, NULL)
@@ -78,10 +53,7 @@ t2;
 JSON_ARRAY_APPEND(NULL, a, JSON_COMPACT(1))	JSON_ARRAY_APPEND('[1,2,3]', a, NULL)
 NULL	NULL
 TRUNCATE t2;
-INSERT INTO
-t2
-VALUES
-('$**[0]');
+INSERT INTO t2 VALUES ('$**[0]');
 error ER_INVALID_JSON_PATH_WILDCARD
 SELECT
 JSON_ARRAY_APPEND(JSON_COMPACT('{"a": {"b": [3]}}'), a, 6)

mysql-test/columnstore/basic/r/func_json_array_insert.result

@@ -5,35 +5,16 @@ USE json_array_insert_db;
 # Test of JSON_ARRAY_INSERT function.
 # ----------------------------------------------------------------------
 CREATE TABLE t1(a TEXT, p TEXT, v TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t1
-VALUES
-('[1,2,3]', '$[0]', 2),
-('[1,2,3]', '$[0]', 1.2),
-('[1,2,3]', '$[0]', 'key1'),
-('[1,2,3]', '$[0]', TRUE),
-('[1,2,3]', '$[0]', false),
-('[1,2,3]', '$[0]', NULL),
-(
-'{"a": "foo", "b": "bar", "c": "wibble" }',
-'$.b',
-4
-),
-(
-'{"a": "foo", "b": "bar", "c": "wibble" }',
-'$.c',
-'grape'
-    ),
-(
-'{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}',
-'$.b',
-4
-),
-(
-'{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}',
-'$.c',
-'grape'
-    );
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 2);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 1.2);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 'key1');
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', TRUE);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', false);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', NULL);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": "bar", "c": "wibble" }', '$.b', 4);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": "bar", "c": "wibble" }', '$.c', 'grape');
+INSERT INTO t1 VALUES ('{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}', '$.b', 4);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}', '$.c', 'grape');
 SELECT
 a AS arrary,
 p AS path,
@@ -54,10 +35,7 @@ arrary	path	value	result
 {"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}	$.c	grape	NULL
 # NULL args
 CREATE TABLE t2(a TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t2
-VALUES
-('[1,2,3]');
+INSERT INTO t2 VALUES ('[1,2,3]');
 SELECT
 JSON_ARRAY_INSERT(a, NULL, JSON_COMPACT(1)),
 JSON_ARRAY_INSERT(a, '$', NULL)
@@ -66,10 +44,7 @@ t2;
 JSON_ARRAY_INSERT(a, NULL, JSON_COMPACT(1))	JSON_ARRAY_INSERT(a, '$', NULL)
 NULL	NULL
 TRUNCATE t2;
-INSERT INTO
-t2
-VALUES
-('$.b');
+INSERT INTO t2 VALUES ('$.b');
 SELECT
 JSON_ARRAY_INSERT(NULL, a, JSON_COMPACT(1)),
 JSON_ARRAY_INSERT('[1,2,3]', a, NULL)
@@ -78,10 +53,7 @@ t2;
 JSON_ARRAY_INSERT(NULL, a, JSON_COMPACT(1))	JSON_ARRAY_INSERT('[1,2,3]', a, NULL)
 NULL	NULL
 TRUNCATE t2;
-INSERT INTO
-t2
-VALUES
-('$**[0]');
+INSERT INTO t2 VALUES ('$**[0]');
 error ER_INVALID_JSON_PATH_WILDCARD
 SELECT
 JSON_ARRAY_INSERT(JSON_COMPACT('{"a": {"b": [3]}}'), a, 6)

mysql-test/columnstore/basic/r/func_json_contains.result

@@ -5,16 +5,13 @@ USE json_contains_db;
 # Test of JSON_CONTAINS function.
 # ----------------------------------------------------------------------
 CREATE TABLE t1(j LONGTEXT, v LONGTEXT, p LONGTEXT) ENGINE = columnstore;
-INSERT INTO
-t1
-VALUES
-('{"k1":123, "k2":345}', '123', '$.k1'),
-('', '', '$'),
-('null', 'null', '$'),
-('"10"', '"10"', '$'),
-('"10"', '10', '$'),
-('10.1', '10', '$'),
-('10.0', '10', '$');
+INSERT INTO t1 VALUES ('{"k1":123, "k2":345}', '123', '$.k1');
+INSERT INTO t1 VALUES ('', '', '$');
+INSERT INTO t1 VALUES ('null', 'null', '$');
+INSERT INTO t1 VALUES ('"10"', '"10"', '$');
+INSERT INTO t1 VALUES ('"10"', '10', '$');
+INSERT INTO t1 VALUES ('10.1', '10', '$');
+INSERT INTO t1 VALUES ('10.0', '10', '$');
 SELECT
 j AS json,
 v AS value,
@@ -31,28 +28,22 @@ null	null	$	1
 10.1	10	$	0
 10.0	10	$	1
 CREATE TABLE t2(j LONGTEXT, v LONGTEXT) ENGINE = columnstore;
-INSERT INTO
-t2
-VALUES
-('"you"', '"you"'),
-('"youth"', '"you"'),
-('[1]', '1'),
-('[2, 1]', '1'),
-('[2, [2, 3], 1]', '1'),
-('[4, [2, 3], 1]', '2'),
-('[2, 1]', '[1, 2]'),
-('[2, 1]', '[1, 0, 2]'),
-('[2, 0, 3, 1]', '[1, 2]'),
-('{"b":[1,2], "a":1}', '{"a":1, "b":2}'),
-('{"a":1}', '{}'),
-('[1, {"a":1}]', '{}'),
-('[1, {"a":1}]', '{"a":1}'),
-('[{"abc":"def", "def":"abc"}]', '["foo","bar"]'),
-(
-'[{"abc":"def", "def":"abc"}, "bar"]',
-'["bar", {}]'
-    ),
-('[{"a":"b"},{"c":"d"}]', '{"c":"d"}');
+INSERT INTO t2 VALUES ('"you"', '"you"');
+INSERT INTO t2 VALUES ('"youth"', '"you"');
+INSERT INTO t2 VALUES ('[1]', '1');
+INSERT INTO t2 VALUES ('[2, 1]', '1');
+INSERT INTO t2 VALUES ('[2, [2, 3], 1]', '1');
+INSERT INTO t2 VALUES ('[4, [2, 3], 1]', '2');
+INSERT INTO t2 VALUES ('[2, 1]', '[1, 2]');
+INSERT INTO t2 VALUES ('[2, 1]', '[1, 0, 2]');
+INSERT INTO t2 VALUES ('[2, 0, 3, 1]', '[1, 2]');
+INSERT INTO t2 VALUES ('{"b":[1,2], "a":1}', '{"a":1, "b":2}');
+INSERT INTO t2 VALUES ('{"a":1}', '{}');
+INSERT INTO t2 VALUES ('[1, {"a":1}]', '{}');
+INSERT INTO t2 VALUES ('[1, {"a":1}]', '{"a":1}');
+INSERT INTO t2 VALUES ('[{"abc":"def", "def":"abc"}]', '["foo","bar"]');
+INSERT INTO t2 VALUES ('[{"abc":"def", "def":"abc"}, "bar"]', '["bar", {}]');
+INSERT INTO t2 VALUES ('[{"a":"b"},{"c":"d"}]', '{"c":"d"}');
 SELECT
 j AS json,
 v AS value,

mysql-test/columnstore/basic/r/func_json_contains_path.result

@@ -5,16 +5,13 @@ USE json_contains_path_db;
 # Test of JSON_CONTAINS_PATH function.
 # ----------------------------------------------------------------------
 CREATE TABLE t1(j TEXT, r TEXT, p TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t1
-VALUES
-('{"key1":1, "key2":[2,3]}', "oNE", "$.key2[1]"),
-('{"key1":1, "key2":[2,3]}', "oNE", "$.key2[10]"),
-('{"key1":1, "key2":[2,3]}', "oNE", "$.ma"),
-('{"key1":1, "key2":[2,3]}', "one", "$.key1"),
-('{ "a": true }', NULL, '$.a'),
-('{ "a": true }', 'all', NULL),
-('{"a":{"b":"c"}}', 'one', '$.a.*');
+INSERT INTO t1 VALUES ('{"key1":1, "key2":[2,3]}', "oNE", "$.key2[1]");
+INSERT INTO t1 VALUES ('{"key1":1, "key2":[2,3]}', "oNE", "$.key2[10]");
+INSERT INTO t1 VALUES ('{"key1":1, "key2":[2,3]}', "oNE", "$.ma");
+INSERT INTO t1 VALUES ('{"key1":1, "key2":[2,3]}', "one", "$.key1");
+INSERT INTO t1 VALUES ('{ "a": true }', NULL, '$.a');
+INSERT INTO t1 VALUES ('{ "a": true }', 'all', NULL);
+INSERT INTO t1 VALUES ('{"a":{"b":"c"}}', 'one', '$.a.*');
 SELECT
 j AS json,
 r AS return_flag,
@@ -31,27 +28,9 @@ json	return_flag	path	result
 { "a": true }	all	NULL	NULL
 {"a":{"b":"c"}}	one	$.a.*	1
 CREATE TABLE t2(j TEXT, r TEXT, p1 TEXT, p2 TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t2
-VALUES
-(
-'{"key1":1, "key2":[2,3]}',
-"one",
-"$.key1",
-"$.ma"
-    ),
-(
-'{"key1":1, "key2":[2,3]}',
-"aLl",
-"$.key1",
-"$.ma"
-    ),
-(
-'{"key1":1, "key2":[2,3]}',
-"aLl",
-"$.key1",
-"$.key2"
-    );
+INSERT INTO t2 VALUES ('{"key1":1, "key2":[2,3]}', "one", "$.key1", "$.ma");
+INSERT INTO t2 VALUES ('{"key1":1, "key2":[2,3]}', "aLl", "$.key1", "$.ma");
+INSERT INTO t2 VALUES ('{"key1":1, "key2":[2,3]}', "aLl", "$.key1", "$.key2");
 SELECT
 j AS json,
 r AS return_flag,

mysql-test/columnstore/basic/r/func_json_exists.result

@@ -6,16 +6,12 @@ USE json_exists_db;
 # ----------------------------------------------------------------------
 # Test case 0
 CREATE TABLE t1(j TEXT, p TEXT) ENGINE = columnstore;
-SET
-@json = '{"key1":"xxxx", "key2":[1, 2, 3]}';
-INSERT INTO
-t1
-VALUES
-(@json, '$.key1'),
-(@json, '$.key1[0]'),
-(@json, '$.key2'),
-(@json, '$.key2[1]'),
-(@json, '$.key2[10]');
+SET @json = '{"key1":"xxxx", "key2":[1, 2, 3]}';
+INSERT INTO t1 VALUES (@json, '$.key1');
+INSERT INTO t1 VALUES (@json, '$.key1[0]');
+INSERT INTO t1 VALUES (@json, '$.key2');
+INSERT INTO t1 VALUES (@json, '$.key2[1]');
+INSERT INTO t1 VALUES (@json, '$.key2[10]');
 SELECT
 j,
 p,

mysql-test/columnstore/basic/r/func_json_extract.result

@@ -8,26 +8,22 @@ USE json_extract_db;
 # Single path expression
 
 CREATE TABLE t1(j LONGTEXT, p LONGTEXT) ENGINE = COLUMNSTORE;
-SET
-@json = '[1, "val2", [3.1, -4]]';
-INSERT INTO
-t1
-VALUES
-(@json, '$[0]'),
-(@json, '$[1]'),
-(@json, '$[2]'),
-(@json, '$[3]'),
-(@json, '$[2][0]'),
-(@json, '$[2][1]'),
-(@json, '$[2][10]'),
-(@json, '$'),
-('1', '$'),
-('[10, 20, [30, 40], 1, 10]', '$[1]'),
-('{"key1":"asd", "key2":[2,3]}', "$.key1"),
-('{"key0":true, "key1":"qwe"}', "$.key1"),
-('[10, 20, [30, 40]]', '$[2][*]'),
-('[10, 20, [{"a":3}, 30, 40]]', '$[2][*]'),
-(json_object('foo', 'foobar'), '$');
+SET @json = '[1, "val2", [3.1, -4]]';
+INSERT INTO t1 VALUES (@json, '$[0]');
+INSERT INTO t1 VALUES (@json, '$[1]');
+INSERT INTO t1 VALUES (@json, '$[2]');
+INSERT INTO t1 VALUES (@json, '$[3]');
+INSERT INTO t1 VALUES (@json, '$[2][0]');
+INSERT INTO t1 VALUES (@json, '$[2][1]');
+INSERT INTO t1 VALUES (@json, '$[2][10]');
+INSERT INTO t1 VALUES (@json, '$');
+INSERT INTO t1 VALUES ('1', '$');
+INSERT INTO t1 VALUES ('[10, 20, [30, 40], 1, 10]', '$[1]');
+INSERT INTO t1 VALUES ('{"key1":"asd", "key2":[2,3]}', "$.key1");
+INSERT INTO t1 VALUES ('{"key0":true, "key1":"qwe"}', "$.key1");
+INSERT INTO t1 VALUES ('[10, 20, [30, 40]]', '$[2][*]');
+INSERT INTO t1 VALUES ('[10, 20, [{"a":3}, 30, 40]]', '$[2][*]');
+INSERT INTO t1 VALUES (json_object('foo', 'foobar'), '$');
 SELECT
 j,
 p,
@@ -54,22 +50,11 @@ j	p	result
 # Multiple path expression
 
 CREATE TABLE t2(j LONGTEXT, p1 LONGTEXT, p2 LONGTEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t2
-VALUES
-(
-'{"key1":"asd", "key2":[2,3]}',
-"$.keyX",
-"$.keyY"
-      ),
-(
-'{"key1":"asd", "key2":[2,3]}',
-"$.key1",
-"$.key2"
-      ),
-('{"key1":5, "key2":[2,3]}', "$.key1", "$.key2"),
-('[10, 20, [30, 40], 1, 10]', '$[1]', '$[25]'),
-('[{"a": [3, 4]}, {"b": 2}]', '$[0].a', '$[1].a');
+INSERT INTO t2 VALUES ('{"key1":"asd", "key2":[2,3]}', "$.keyX", "$.keyY");
+INSERT INTO t2 VALUES ('{"key1":"asd", "key2":[2,3]}', "$.key1", "$.key2");
+INSERT INTO t2 VALUES ('{"key1":5, "key2":[2,3]}', "$.key1", "$.key2");
+INSERT INTO t2 VALUES ('[10, 20, [30, 40], 1, 10]', '$[1]', '$[25]');
+INSERT INTO t2 VALUES ('[{"a": [3, 4]}, {"b": 2}]', '$[0].a', '$[1].a');
 SELECT
 j,
 p1,

mysql-test/columnstore/basic/r/func_json_insert.result

@@ -5,34 +5,15 @@ USE json_insert_de;
 # Test of JSON_INSERT|REPLACE|SET function.
 # ----------------------------------------------------------------------
 CREATE TABLE t1(j TEXT, p TEXT, v TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t1
-VALUES
-(
-'{"a":1, "b":{"c":1}, "d":[1, 2]}',
-'$.b.k1',
-'word'
-    ),
-('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.d[3]', 3),
-('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.a[2]', 2),
-(
-'{"a":1, "b":{"c":1}, "d":[1, 2]}',
-'$.b.c',
-'word'
-    ),
-('1', '$[0]', 4),
-('[]', '$[0][0]', 100),
-('1', '$[0][0]', 100),
-(
-'{ "a": 1, "b": [2, 3]}',
-'$.a',
-10
-),
-(
-'{ "a": 1, "b": [2, 3]}',
-'$.b',
-'[true, false]'
-    );
+INSERT INTO t1 VALUES ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.b.k1', 'word');
+INSERT INTO t1 VALUES ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.d[3]', 3);
+INSERT INTO t1 VALUES ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.a[2]', 2);
+INSERT INTO t1 VALUES ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.b.c', 'word');
+INSERT INTO t1 VALUES ('1', '$[0]', 4);
+INSERT INTO t1 VALUES ('[]', '$[0][0]', 100);
+INSERT INTO t1 VALUES ('1', '$[0][0]', 100);
+INSERT INTO t1 VALUES ('{ "a": 1, "b": [2, 3]}', '$.a', 10);
+INSERT INTO t1 VALUES ('{ "a": 1, "b": [2, 3]}', '$.b', '[true, false]');
 SELECT
 j AS json,
 p AS path,

mysql-test/columnstore/basic/r/func_json_merge_patch.result

@@ -4,24 +4,23 @@ Note	1008	Can't drop database 'json_merge_patch_db'; database doesn't exist
 CREATE DATABASE json_merge_patch_db;
 USE json_merge_patch_db;
 CREATE TABLE t1(l1 TEXT, l2 TEXT) ENGINE = columnstore;
-INSERT INTO t1(l1, l2) VALUES
-('{"a":"b"}', '{"a":"c"}'),
-('{"a":"b"}', '{"b":"c"}'),
-('{"a":"b"}', '{"a":null}'),
-('{"a":"b", "b":"c"}', '{"a":null}'),
-('{"a":["b"]}', '{"a":"c"}'),
-('{"a":"c"}', '{"a":["b"]}'),
-('{"a": {"b":"c"}}', '{"a": {"b":"d", "c":null}}'),
-('{"a":[{"b":"c"}]}', '{"a": [1]}'),
-('["a","b"]', '["c","d"]'),
-('{"a":"b"}', '["c"]'),
-('{"a":"foo"}', 'null'),
-('{"a":"foo"}', '"bar"'),
-('{"e":null}', '{"a":1}'),
-('[1,2]', '{"a":"b", "c":null}'),
-('{}', '{"a":{"bb":{"ccc":null}}}'),
-(NULL, '{}'),
-('{}', NULL);
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b"}', '{"a":"c"}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b"}', '{"b":"c"}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b"}', '{"a":null}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b", "b":"c"}', '{"a":null}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":["b"]}', '{"a":"c"}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"c"}', '{"a":["b"]}');
+INSERT INTO t1(l1, l2) VALUES ('{"a": {"b":"c"}}', '{"a": {"b":"d", "c":null}}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":[{"b":"c"}]}', '{"a": [1]}');
+INSERT INTO t1(l1, l2) VALUES ('["a","b"]', '["c","d"]');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b"}', '["c"]');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"foo"}', 'null');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"foo"}', '"bar"');
+INSERT INTO t1(l1, l2) VALUES ('{"e":null}', '{"a":1}');
+INSERT INTO t1(l1, l2) VALUES ('[1,2]', '{"a":"b", "c":null}');
+INSERT INTO t1(l1, l2) VALUES ('{}', '{"a":{"bb":{"ccc":null}}}');
+INSERT INTO t1(l1, l2) VALUES (NULL, '{}');
+INSERT INTO t1(l1, l2) VALUES ('{}', NULL);
 SELECT l1, l2,
 JSON_MERGE_PATCH(l1, l2) AS `l1 + l2`
 FROM t1;
@@ -45,11 +44,10 @@ NULL	{}	NULL
 {}	NULL	NULL
 DROP TABLE t1;
 CREATE TABLE t2(l1 TEXT, l2 TEXT, l3 TEXT) ENGINE = columnstore;
-INSERT INTO t2 VALUES
-('{"a":"b"}', NULL, '{"c":"d"}'),
-(NULL, '[1,2,3]', '[4,5,6]'),
-(NULL, 'a', 'b'),
-('{"a":"b"}', '[1,2,3]', '{"c":null,"d":"e"}');
+INSERT INTO t2 VALUES ('{"a":"b"}', NULL, '{"c":"d"}');
+INSERT INTO t2 VALUES (NULL, '[1,2,3]', '[4,5,6]');
+INSERT INTO t2 VALUES (NULL, 'a', 'b');
+INSERT INTO t2 VALUES ('{"a":"b"}', '[1,2,3]', '{"c":null,"d":"e"}');
 SELECT l1, l2, l3,
 JSON_MERGE_PATCH(l1, l2, l3) AS merged
 FROM t2;
@@ -62,12 +60,11 @@ DROP TABLE t2;
 CREATE TABLE t3(l1 TEXT, l2 TEXT) ENGINE = columnstore;
 SELECT JSON_MERGE_PATCH() FROM t3;
 ERROR 42000: Incorrect parameter count in the call to native function 'JSON_MERGE_PATCH'
-INSERT INTO t3(l1, l2) VALUES('{}', '{"a":"c"}');
+INSERT INTO t3(l1, l2) VALUES ('{}', '{"a":"c"}');
 SELECT l1, JSON_MERGE_PATCH(l1) AS merged FROM t3;
 ERROR 42000: Incorrect parameter count in the call to native function 'JSON_MERGE_PATCH'
-INSERT INTO t3(l1, l2) VALUES
-('{', '[1,2,3]'),
-('{"a":"b"}', '[1,');
+INSERT INTO t3(l1, l2) VALUES ('{', '[1,2,3]');
+INSERT INTO t3(l1, l2) VALUES ('{"a":"b"}', '[1,');
 SELECT l1, l2, JSON_MERGE_PATCH(l1, l2) AS merged FROM t3;
 l1	l2	merged
 {}	{"a":"c"}	{"a": "c"}

mysql-test/columnstore/basic/r/func_json_remove.result

@@ -5,13 +5,10 @@ USE json_remove_db;
 # Test of JSON_REMOVE function.
 # ----------------------------------------------------------------------
 CREATE TABLE t1(j TEXT, p TEXT) ENGINE = columnstore;
-INSERT INTO
-t1
-VALUES
-('["a", ["b", "c"], "d"]', '$[0]'),
-('["a", ["b", "c"], "d"]', '$[1]'),
-('["a", ["b", "c"], "d"]', '$[1][0]'),
-('["a", ["b", "c"], "d"]', '$[0]');
+INSERT INTO t1 VALUES ('["a", ["b", "c"], "d"]', '$[0]');
+INSERT INTO t1 VALUES ('["a", ["b", "c"], "d"]', '$[1]');
+INSERT INTO t1 VALUES ('["a", ["b", "c"], "d"]', '$[1][0]');
+INSERT INTO t1 VALUES ('["a", ["b", "c"], "d"]', '$[0]');
 SELECT
 j AS json,
 p AS path,
@@ -24,14 +21,11 @@ json	path	result
 ["a", ["b", "c"], "d"]	$[1][0]	["a", ["c"], "d"]
 ["a", ["b", "c"], "d"]	$[0]	[["b", "c"], "d"]
 CREATE TABLE t2(j TEXT, p TEXT) ENGINE = columnstore;
-INSERT INTO
-t2
-VALUES
-('{"a": 1, "b": [2, 3]}', '$.a'),
-('{"a": 1, "b": [2, 3]}', '$.a[0]'),
-('{"a": 1, "b": [2, 3]}', '$.b'),
-('{"a": 1, "b": [2, 3]}', '$.b[0]'),
-('{"a": 1, "b": [2, 3]}', '$.b[1]');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.a');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.a[0]');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.b');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.b[0]');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.b[1]');
 SELECT
 j AS json,
 p AS path,

mysql-test/columnstore/basic/r/func_json_valid.result

@@ -8,23 +8,20 @@ USE json_valid_db;
 # String literal - valid JSON
 #
 CREATE TABLE t1(l LONGTEXT) ENGINE = COLUMNSTORE;
-INSERT INTO
-t1
-VALUES
-('123'),
-('-123'),
-('5000000000'),
-('-5000000000'),
-('1.23'),
-('"123"'),
-('true'),
-('false'),
-('null'),
-('{"address": "Trondheim"}'),
-(JSON_OBJECT()),
-(JSON_OBJECT(1, 2)),
-(JSON_ARRAY()),
-(JSON_ARRAY(1, 2));
+INSERT INTO t1 VALUES ('123');
+INSERT INTO t1 VALUES ('-123');
+INSERT INTO t1 VALUES ('5000000000');
+INSERT INTO t1 VALUES ('-5000000000');
+INSERT INTO t1 VALUES ('1.23');
+INSERT INTO t1 VALUES ('"123"');
+INSERT INTO t1 VALUES ('true');
+INSERT INTO t1 VALUES ('false');
+INSERT INTO t1 VALUES ('null');
+INSERT INTO t1 VALUES ('{"address": "Trondheim"}');
+INSERT INTO t1 VALUES (JSON_OBJECT());
+INSERT INTO t1 VALUES (JSON_OBJECT(1, 2));
+INSERT INTO t1 VALUES (JSON_ARRAY());
+INSERT INTO t1 VALUES (JSON_ARRAY(1, 2));
 SELECT
 l AS raw,
 JSON_VALID(l) AS is_valid,
@@ -50,14 +47,11 @@ null	1	1
 # String literal - invalid JSON
 #
 TRUNCATE t1;
-INSERT INTO
-t1
-VALUES
-('12 3'),
-('{key:value}'),
-('{key:value'),
-('[1,2,]'),
-('[1,2');
+INSERT INTO t1 VALUES ('12 3');
+INSERT INTO t1 VALUES ('{key:value}');
+INSERT INTO t1 VALUES ('{key:value');
+INSERT INTO t1 VALUES ('[1,2,]');
+INSERT INTO t1 VALUES ('[1,2');
 SELECT
 l AS raw,
 JSON_VALID(l) AS is_valid,
@@ -74,12 +68,8 @@ raw	is_valid	compact
 # String literal - not in UTF-8
 #
 TRUNCATE t1;
-SET
-NAMES 'ascii';
-INSERT INTO
-t1
-VALUES
-('123');
+SET NAMES 'ascii';
+INSERT INTO t1 VALUES ('123');
 SELECT
 l AS raw,
 JSON_VALID(l) AS is_valid,
@@ -88,16 +78,12 @@ FROM
 t1;
 raw	is_valid	compact
 123	1	1
-SET
-NAMES 'utf8';
+SET NAMES 'utf8';
 #
 # Bare NULL
 #
 TRUNCATE t1;
-INSERT INTO
-t1
-VALUES
-(NULL);
+INSERT INTO t1 VALUES (NULL);
 SELECT
 JSON_VALID(l)
 FROM
@@ -108,10 +94,7 @@ NULL
 # Function result - string
 #
 TRUNCATE t1;
-INSERT INTO
-t1
-VALUES
-(UPPER('"abc"'));
+INSERT INTO t1 VALUES (UPPER('"abc"'));
 SELECT
 JSON_VALID(l)
 FROM
@@ -122,28 +105,20 @@ JSON_VALID(l)
 # Function result - string not in UTF-8
 #
 TRUNCATE t1;
-SET
-NAMES 'latin1';
-INSERT INTO
-t1
-VALUES
-(UPPER('"abc"'));
+SET NAMES 'latin1';
+INSERT INTO t1 VALUES (UPPER('"abc"'));
 SELECT
 JSON_VALID(l)
 FROM
 t1;
 JSON_VALID(l)
 1
-SET
-NAMES 'utf8';
+SET NAMES 'utf8';
 #
 # Function result - date, not valid as JSON without CAST
 #
 TRUNCATE t1;
-INSERT INTO
-t1
-VALUES
-(CAST('2015-01-15' AS DATE));
+INSERT INTO t1 VALUES (CAST('2015-01-15' AS DATE));
 SELECT
 JSON_VALID(l)
 FROM
@@ -154,13 +129,10 @@ JSON_VALID(l)
 # The date string doesn't parse as JSON text, so wrong:
 #
 TRUNCATE t1;
-INSERT INTO
-t1
-VALUES
-(
+INSERT INTO t1 VALUES (
 CAST(
 CAST('2015-01-15' AS DATE) AS CHAR CHARACTER SET 'utf8'
-        )
+    )
 );
 SELECT
 JSON_VALID(l)
@@ -172,14 +144,8 @@ JSON_VALID(l)
 # Function result - NULL
 #
 TRUNCATE t1;
-INSERT INTO
-t1
-VALUES
-(UPPER(NULL));
-INSERT INTO
-t1
-VALUES
-(UPPER(CAST(NULL AS CHAR)));
+INSERT INTO t1 VALUES (UPPER(NULL));
+INSERT INTO t1 VALUES (UPPER(CAST(NULL AS CHAR)));
 SELECT
 JSON_VALID(l)
 FROM

mysql-test/columnstore/basic/r/func_json_value.result

@@ -5,15 +5,17 @@ USE json_value_db;
 # Test of JSON_VALUE function.
 # ----------------------------------------------------------------------
 CREATE TABLE t1(s TEXT, p TEXT) ENGINE = columnstore;
-INSERT INTO t1 VALUES('{"key1":123}', '$.key2'),
-('{"key1":123}', '$.key1'),
-('{"key1":[1,2,3]}', '$.key1'),
-('{"key1": [1,2,3], "key1":123}', '$.key1'),
-('{ "x": [0,1], "y": "[0,1]", "z": "Mon\\\"t\\\"y" }','$.z'),
-('{"\\"key1":123}', '$."\\"key1"'),
-('{"\\"key1\\"":123}', '$."\\"key1\\""'),
-('{"key 1":123}', '$."key 1"');
-SELECT s as json_text, p as path, JSON_VALUE(s, p) as json_value, JSON_QUERY(s, p) as json_query
+INSERT INTO t1 VALUES ('{"key1":123}', '$.key2');
+INSERT INTO t1 VALUES ('{"key1":123}', '$.key1');
+INSERT INTO t1 VALUES ('{"key1":[1,2,3]}', '$.key1');
+INSERT INTO t1 VALUES ('{"key1": [1,2,3], "key1":123}', '$.key1');
+INSERT INTO t1 VALUES ('{ "x": [0,1], "y": "[0,1]", "z": "Mon\\\"t\\\"y" }', '$.z');
+INSERT INTO t1 VALUES ('{"\\"key1":123}', '$."\\"key1"');
+INSERT INTO t1 VALUES ('{"\\"key1\\"":123}', '$."\\"key1\\""');
+INSERT INTO t1 VALUES ('{"key 1":123}', '$."key 1"');
+SELECT s AS json_text, p AS path,
+JSON_VALUE(s, p) AS json_value,
+JSON_QUERY(s, p) AS json_query
 FROM t1;
 json_text	path	json_value	json_query
 {"key1":123}	$.key2	NULL	NULL
@@ -25,9 +27,9 @@ json_text	path	json_value	json_query
 {"\"key1\"":123}	$."\"key1\""	123	NULL
 {"key 1":123}	$."key 1"	123	NULL
 CREATE TABLE t2(s TEXT) ENGINE = columnstore;
-INSERT INTO t2 VALUES('{"key1":123, "key2":{"key3":"value3"}}'),
-('{"key1":123, "key3":[1,2,3]}'),
-('{"key1":123, "key2":"[1]"}');
+INSERT INTO t2 VALUES ('{"key1":123, "key2":{"key3":"value3"}}');
+INSERT INTO t2 VALUES ('{"key1":123, "key3":[1,2,3]}');
+INSERT INTO t2 VALUES ('{"key1":123, "key2":"[1]"}');
 SELECT s as json_text, '$.key1' , JSON_VALUE(s, '$.key1') as json_value, JSON_QUERY(s, '$.key1') as json_query
 FROM t2;
 json_text	$.key1	json_value	json_query
@@ -49,7 +51,15 @@ json_text	$.key3	json_value	json_query
 DROP TABLE t2;
 DROP TABLE t1;
 CREATE TABLE zu (hu TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO zu(hu) VALUES ('{}'), (NULL), ('{ "": "huh", "10001" : "10001", "10002" : "10001", "10003" : "10001", "10004" : "10001", "10005" : "10001", "10006" : "10001", "10007" : "10001", "10008" : "10001", "10009" : "10001", "10010" : "10001", "10011" : "10001", "10012" : "10001", "10013" : "10001", "10014" : "10001", "10015" : "10001", "10016" : "10001", "10017" : "10001", "10018" : "10001", "10019" : "10001", "10020" : "10001", "buga" : ""}');
+INSERT INTO zu(hu) VALUES ('{}');
+INSERT INTO zu(hu) VALUES (NULL);
+INSERT INTO zu(hu) VALUES (
+'{ "": "huh", "10001" : "10001", "10002" : "10001", "10003" : "10001", "10004" : "10001",
+     "10005" : "10001", "10006" : "10001", "10007" : "10001", "10008" : "10001", "10009" : "10001",
+     "10010" : "10001", "10011" : "10001", "10012" : "10001", "10013" : "10001", "10014" : "10001",
+     "10015" : "10001", "10016" : "10001", "10017" : "10001", "10018" : "10001", "10019" : "10001",
+     "10020" : "10001", "buga" : "" }'
+);
 INSERT INTO zu(hu) SELECT hu FROM zu;
 INSERT INTO zu(hu) SELECT hu FROM zu;
 INSERT INTO zu(hu) SELECT hu FROM zu;

mysql-test/columnstore/basic/r/func_jsonarrayagg.result

@@ -4,7 +4,14 @@ Note	1008	Can't drop database 'json_arrayagg_db'; database doesn't exist
 CREATE DATABASE json_arrayagg_db;
 USE json_arrayagg_db;
 CREATE TABLE t1 (a INT, b INT)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1, 1),(2, 1), (1, 1),(2, 1), (3, 2),(2, 2),(2, 2),(2, 2);
+INSERT INTO t1 VALUES (1, 1);
+INSERT INTO t1 VALUES (2, 1);
+INSERT INTO t1 VALUES (1, 1);
+INSERT INTO t1 VALUES (2, 1);
+INSERT INTO t1 VALUES (3, 2);
+INSERT INTO t1 VALUES (2, 2);
+INSERT INTO t1 VALUES (2, 2);
+INSERT INTO t1 VALUES (2, 2);
 SELECT JSON_VALID(JSON_ARRAYAGG(a)) FROM t1;
 JSON_VALID(JSON_ARRAYAGG(a))
 1
@@ -20,7 +27,10 @@ DROP TABLE t1;
 # Real aggregation
 #
 CREATE TABLE t1 (a FLOAT, b DOUBLE, c DECIMAL(10, 2))ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1.0, 2.0, 3.0),(1.0, 3.0, 9.0),(1.0, 4.0, 16.0),(1.0, 5.0, 25.0);
+INSERT INTO t1 VALUES (1.0, 2.0, 3.0);
+INSERT INTO t1 VALUES (1.0, 3.0, 9.0);
+INSERT INTO t1 VALUES (1.0, 4.0, 16.0);
+INSERT INTO t1 VALUES (1.0, 5.0, 25.0);
 SELECT JSON_VALID(JSON_ARRAYAGG(a)) FROM t1;
 JSON_VALID(JSON_ARRAYAGG(a))
 1
@@ -32,7 +42,10 @@ DROP TABLE t1;
 # Boolean aggregation
 #
 CREATE TABLE t1 (a BOOLEAN, b BOOLEAN)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (TRUE, TRUE), (TRUE, FALSE), (FALSE, TRUE), (FALSE, FALSE);
+INSERT INTO t1 VALUES (TRUE, TRUE);
+INSERT INTO t1 VALUES (TRUE, FALSE);
+INSERT INTO t1 VALUES (FALSE, TRUE);
+INSERT INTO t1 VALUES (FALSE, FALSE);
 SELECT JSON_VALID(JSON_ARRAYAGG(a)) FROM t1;
 JSON_VALID(JSON_ARRAYAGG(a))
 1
@@ -51,9 +64,10 @@ DROP TABLE t1;
 # Aggregation of strings with quoted
 #
 CREATE TABLE t1 (a VARCHAR(80))ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES
-('"double_quoted_value"'), ("'single_quoted_value'"),
-('"double_quoted_value"'), ("'single_quoted_value'");
+INSERT INTO t1 VALUES ('"double_quoted_value"');
+INSERT INTO t1 VALUES ("'single_quoted_value'");
+INSERT INTO t1 VALUES ('"double_quoted_value"');
+INSERT INTO t1 VALUES ("'single_quoted_value'");
 SELECT JSON_VALID(JSON_ARRAYAGG(a)) FROM t1;
 JSON_VALID(JSON_ARRAYAGG(a))
 1
@@ -65,9 +79,20 @@ DROP TABLE t1;
 # Strings and NULLs
 #
 CREATE TABLE t1 (a INT, b VARCHAR(80))ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES
-(1, "Hello"),(1, "World"), (2, "This"),(2, "Will"), (2, "Work"),(2, "!"), (3, NULL),
-(1, "Hello"),(1, "World"), (2, "This"),(2, "Will"), (2, "Work"),(2, "!"), (3, NULL);
+INSERT INTO t1 VALUES (1, "Hello");
+INSERT INTO t1 VALUES (1, "World");
+INSERT INTO t1 VALUES (2, "This");
+INSERT INTO t1 VALUES (2, "Will");
+INSERT INTO t1 VALUES (2, "Work");
+INSERT INTO t1 VALUES (2, "!");
+INSERT INTO t1 VALUES (3, NULL);
+INSERT INTO t1 VALUES (1, "Hello");
+INSERT INTO t1 VALUES (1, "World");
+INSERT INTO t1 VALUES (2, "This");
+INSERT INTO t1 VALUES (2, "Will");
+INSERT INTO t1 VALUES (2, "Work");
+INSERT INTO t1 VALUES (2, "!");
+INSERT INTO t1 VALUES (3, NULL);
 SELECT JSON_VALID(JSON_ARRAYAGG(b)) FROM t1;
 JSON_VALID(JSON_ARRAYAGG(b))
 1
@@ -102,18 +127,6 @@ JSON_ARRAYAGG(b LIMIT 2)
 ["Hello","World","Hello","World"]
 ["This","Will","Work","!","This","Will","Work","!"]
 [null,null]
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
-JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC)
-[1,2,3]
-SELECT JSON_ARRAYAGG(DISTINCT b ORDER BY b ASC) FROM t1;
-JSON_ARRAYAGG(DISTINCT b ORDER BY b ASC)
-[null,"!","Hello","This","Will","Work","World"]
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC LIMIT 2) FROM t1;
-JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC LIMIT 2)
-[1,2,3]
-SELECT JSON_ARRAYAGG(DISTINCT b ORDER BY b ASC LIMIT 2) FROM t1;
-JSON_ARRAYAGG(DISTINCT b ORDER BY b ASC LIMIT 2)
-[null,"!","Hello","This","Will","Work","World"]
 #
 # JSON aggregation
 #
@@ -184,43 +197,42 @@ json_object('x', json_arrayagg(json_object('a', 1)))
 #
 #
 CREATE TABLE t1(a INT, b INT)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1,1), (2,2), (3,3);
-INSERT INTO t1 VALUES (1,1), (2,2), (3,3);
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t1 VALUES (2,2);
+INSERT INTO t1 VALUES (3,3);
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t1 VALUES (2,2);
+INSERT INTO t1 VALUES (3,3);
 SELECT JSON_ARRAYAGG(a) FROM t1;
 JSON_ARRAYAGG(a)
 [1,2,3,1,2,3]
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
-JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC)
-[1,2,3]
-INSERT INTO t1 VALUES (NULL,NULL), (NULL,NULL);
+INSERT INTO t1 VALUES (NULL,NULL);
+INSERT INTO t1 VALUES (NULL,NULL);
 SELECT JSON_ARRAYAGG(a) FROM t1;
 JSON_ARRAYAGG(a)
 [1,2,3,1,2,3,null,null]
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
-JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC)
-[null,1,2,3]
 DROP TABLE t1;
 CREATE TABLE t1(a VARCHAR(10), b INT)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1,1), (2,2), (3,3);
-INSERT INTO t1 VALUES (1,1), (2,2), (3,3);
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t1 VALUES (2,2);
+INSERT INTO t1 VALUES (3,3);
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t1 VALUES (2,2);
+INSERT INTO t1 VALUES (3,3);
 SELECT JSON_ARRAYAGG(a) FROM t1;
 JSON_ARRAYAGG(a)
 [1,2,3,1,2,3]
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
-JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC)
-[1,2,3]
-INSERT INTO t1 VALUES (NULL,NULL), (NULL,NULL);
+INSERT INTO t1 VALUES (NULL,NULL);
+INSERT INTO t1 VALUES (NULL,NULL);
 SELECT JSON_ARRAYAGG(a) FROM t1;
 JSON_ARRAYAGG(a)
 [1,2,3,1,2,3,null,null]
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
-JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC)
-[null,1,2,3]
 DROP TABLE t1;
 #
 #
 CREATE TABLE t1(a VARCHAR(255))ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES ('red'),('blue');
+INSERT INTO t1 VALUES ('red');
+INSERT INTO t1 VALUES ('blue');
 SELECT JSON_ARRAYAGG(a) FROM t1;
 JSON_ARRAYAGG(a)
 ["red","blue"]
@@ -253,8 +265,13 @@ drop table t1;
 SET group_concat_max_len= default;
 CREATE TABLE t1(id int, name varchar(50))ENGINE=COLUMNSTORE;
 CREATE TABLE t2(id int, owner_id int)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1, "name1"), (2, "name2"), (3, "name3");
-INSERT INTO t2 VALUES (1, 1), (2, 1), (3, 2), (4, 3);
+INSERT INTO t1 VALUES (1, "name1");
+INSERT INTO t1 VALUES (2, "name2");
+INSERT INTO t1 VALUES (3, "name3");
+INSERT INTO t2 VALUES (1, 1);
+INSERT INTO t2 VALUES (2, 1);
+INSERT INTO t2 VALUES (3, 2);
+INSERT INTO t2 VALUES (4, 3);
 SELECT t1.id, JSON_ARRAYAGG(JSON_OBJECT('id',t2.id) ORDER BY t2.id) as materials
 from t1 LEFT JOIN t2 on t1.id = t2.owner_id
 GROUP BY t1.id ORDER BY id;
@@ -276,7 +293,8 @@ json_object('a', coalesce(json_object('b', 'c')))
 #
 CREATE TABLE t (a VARCHAR(8))ENGINE=COLUMNSTORE;
 CREATE VIEW v AS SELECT * FROM t;
-INSERT INTO t VALUES ('foo'),('bar');
+INSERT INTO t VALUES ('foo');
+INSERT INTO t VALUES ('bar');
 SELECT JSON_ARRAYAGG(a) AS f FROM v;
 f
 ["foo","bar"]

mysql-test/columnstore/basic/t/func_json_array_append.test

@@ -1,8 +1,8 @@
 --source ../include/have_columnstore.inc
 --disable_warnings
 DROP DATABASE IF EXISTS json_array_append_db;
-
 --enable_warnings
+
 CREATE DATABASE json_array_append_db;
 
 USE json_array_append_db;
@@ -10,37 +10,19 @@ USE json_array_append_db;
 --echo # ----------------------------------------------------------------------
 --echo # Test of JSON_ARRAY_APPEND function.
 --echo # ----------------------------------------------------------------------
+
 CREATE TABLE t1(a TEXT, p TEXT, v TEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-    t1
-VALUES
-    ('[1,2,3]', '$[0]', 2),
-    ('[1,2,3]', '$[0]', 1.2),
-    ('[1,2,3]', '$[0]', 'key1'),
-    ('[1,2,3]', '$[0]', TRUE),
-    ('[1,2,3]', '$[0]', false),
-    ('[1,2,3]', '$[0]', NULL),
-    (
-        '{"a": "foo", "b": "bar", "c": "wibble" }',
-        '$.b',
-        4
-    ),
-    (
-        '{"a": "foo", "b": "bar", "c": "wibble" }',
-        '$.c',
-        'grape'
-    ),
-    (
-        '{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}',
-        '$.b',
-        4
-    ),
-    (
-        '{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}',
-        '$.c',
-        'grape'
-    );
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 2);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 1.2);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 'key1');
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', TRUE);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', false);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', NULL);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": "bar", "c": "wibble" }', '$.b', 4);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": "bar", "c": "wibble" }', '$.c', 'grape');
+INSERT INTO t1 VALUES ('{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}', '$.b', 4);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}', '$.c', 'grape');
 
 SELECT
     a AS arrary,
@@ -53,10 +35,7 @@ FROM
 --echo # NULL args
 CREATE TABLE t2(a TEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-    t2
-VALUES
-    ('[1,2,3]');
+INSERT INTO t2 VALUES ('[1,2,3]');
 
 SELECT
     JSON_ARRAY_APPEND(a, NULL, JSON_COMPACT(1)),
@@ -66,10 +45,7 @@ FROM
 
 TRUNCATE t2;
 
-INSERT INTO
-    t2
-VALUES
-    ('$.b');
+INSERT INTO t2 VALUES ('$.b');
 
 SELECT
     JSON_ARRAY_APPEND(NULL, a, JSON_COMPACT(1)),
@@ -79,10 +55,7 @@ FROM
 
 TRUNCATE t2;
 
-INSERT INTO
-    t2
-VALUES
-    ('$**[0]');
+INSERT INTO t2 VALUES ('$**[0]');
 
 --echo error ER_INVALID_JSON_PATH_WILDCARD
 SELECT
@@ -91,7 +64,5 @@ FROM
     t2;
 
 DROP TABLE t2;
-
 DROP TABLE t1;
-
 DROP DATABASE json_array_append_db;

mysql-test/columnstore/basic/t/func_json_array_insert.test

@@ -1,8 +1,8 @@
 --source ../include/have_columnstore.inc
 --disable_warnings
 DROP DATABASE IF EXISTS json_array_insert_db;
-
 --enable_warnings
+
 CREATE DATABASE json_array_insert_db;
 
 USE json_array_insert_db;
@@ -10,37 +10,19 @@ USE json_array_insert_db;
 --echo # ----------------------------------------------------------------------
 --echo # Test of JSON_ARRAY_INSERT function.
 --echo # ----------------------------------------------------------------------
+
 CREATE TABLE t1(a TEXT, p TEXT, v TEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-    t1
-VALUES
-    ('[1,2,3]', '$[0]', 2),
-    ('[1,2,3]', '$[0]', 1.2),
-    ('[1,2,3]', '$[0]', 'key1'),
-    ('[1,2,3]', '$[0]', TRUE),
-    ('[1,2,3]', '$[0]', false),
-    ('[1,2,3]', '$[0]', NULL),
-    (
-        '{"a": "foo", "b": "bar", "c": "wibble" }',
-        '$.b',
-        4
-    ),
-    (
-        '{"a": "foo", "b": "bar", "c": "wibble" }',
-        '$.c',
-        'grape'
-    ),
-    (
-        '{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}',
-        '$.b',
-        4
-    ),
-    (
-        '{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}',
-        '$.c',
-        'grape'
-    );
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 2);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 1.2);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', 'key1');
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', TRUE);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', false);
+INSERT INTO t1 VALUES ('[1,2,3]', '$[0]', NULL);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": "bar", "c": "wibble" }', '$.b', 4);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": "bar", "c": "wibble" }', '$.c', 'grape');
+INSERT INTO t1 VALUES ('{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}', '$.b', 4);
+INSERT INTO t1 VALUES ('{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]}', '$.c', 'grape');
 
 SELECT
     a AS arrary,
@@ -53,10 +35,7 @@ FROM
 --echo # NULL args
 CREATE TABLE t2(a TEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-    t2
-VALUES
-    ('[1,2,3]');
+INSERT INTO t2 VALUES ('[1,2,3]');
 
 SELECT
     JSON_ARRAY_INSERT(a, NULL, JSON_COMPACT(1)),
@@ -66,10 +45,7 @@ FROM
 
 TRUNCATE t2;
 
-INSERT INTO
-    t2
-VALUES
-    ('$.b');
+INSERT INTO t2 VALUES ('$.b');
 
 SELECT
     JSON_ARRAY_INSERT(NULL, a, JSON_COMPACT(1)),
@@ -79,10 +55,7 @@ FROM
 
 TRUNCATE t2;
 
-INSERT INTO
-    t2
-VALUES
-    ('$**[0]');
+INSERT INTO t2 VALUES ('$**[0]');
 
 --echo error ER_INVALID_JSON_PATH_WILDCARD
 SELECT
@@ -91,7 +64,5 @@ FROM
     t2;
 
 DROP TABLE t2;
-
 DROP TABLE t1;
-
 DROP DATABASE json_array_insert_db;

mysql-test/columnstore/basic/t/func_json_contains.test

@@ -1,8 +1,8 @@
 --source ../include/have_columnstore.inc
 --disable_warnings
 DROP DATABASE IF EXISTS json_contains_db;
-
 --enable_warnings
+
 CREATE DATABASE json_contains_db;
 
 USE json_contains_db;
@@ -10,18 +10,16 @@ USE json_contains_db;
 --echo # ----------------------------------------------------------------------
 --echo # Test of JSON_CONTAINS function.
 --echo # ----------------------------------------------------------------------
+
 CREATE TABLE t1(j LONGTEXT, v LONGTEXT, p LONGTEXT) ENGINE = columnstore;
 
-INSERT INTO
-    t1
-VALUES
-    ('{"k1":123, "k2":345}', '123', '$.k1'),
-    ('', '', '$'),
-    ('null', 'null', '$'),
-    ('"10"', '"10"', '$'),
-    ('"10"', '10', '$'),
-    ('10.1', '10', '$'),
-    ('10.0', '10', '$');
+INSERT INTO t1 VALUES ('{"k1":123, "k2":345}', '123', '$.k1');
+INSERT INTO t1 VALUES ('', '', '$');
+INSERT INTO t1 VALUES ('null', 'null', '$');
+INSERT INTO t1 VALUES ('"10"', '"10"', '$');
+INSERT INTO t1 VALUES ('"10"', '10', '$');
+INSERT INTO t1 VALUES ('10.1', '10', '$');
+INSERT INTO t1 VALUES ('10.0', '10', '$');
 
 SELECT
     j AS json,
@@ -33,28 +31,22 @@ FROM
 
 CREATE TABLE t2(j LONGTEXT, v LONGTEXT) ENGINE = columnstore;
 
-INSERT INTO
-    t2
-VALUES
-    ('"you"', '"you"'),
-    ('"youth"', '"you"'),
-    ('[1]', '1'),
-    ('[2, 1]', '1'),
-    ('[2, [2, 3], 1]', '1'),
-    ('[4, [2, 3], 1]', '2'),
-    ('[2, 1]', '[1, 2]'),
-    ('[2, 1]', '[1, 0, 2]'),
-    ('[2, 0, 3, 1]', '[1, 2]'),
-    ('{"b":[1,2], "a":1}', '{"a":1, "b":2}'),
-    ('{"a":1}', '{}'),
-    ('[1, {"a":1}]', '{}'),
-    ('[1, {"a":1}]', '{"a":1}'),
-    ('[{"abc":"def", "def":"abc"}]', '["foo","bar"]'),
-    (
-        '[{"abc":"def", "def":"abc"}, "bar"]',
-        '["bar", {}]'
-    ),
-    ('[{"a":"b"},{"c":"d"}]', '{"c":"d"}');
+INSERT INTO t2 VALUES ('"you"', '"you"');
+INSERT INTO t2 VALUES ('"youth"', '"you"');
+INSERT INTO t2 VALUES ('[1]', '1');
+INSERT INTO t2 VALUES ('[2, 1]', '1');
+INSERT INTO t2 VALUES ('[2, [2, 3], 1]', '1');
+INSERT INTO t2 VALUES ('[4, [2, 3], 1]', '2');
+INSERT INTO t2 VALUES ('[2, 1]', '[1, 2]');
+INSERT INTO t2 VALUES ('[2, 1]', '[1, 0, 2]');
+INSERT INTO t2 VALUES ('[2, 0, 3, 1]', '[1, 2]');
+INSERT INTO t2 VALUES ('{"b":[1,2], "a":1}', '{"a":1, "b":2}');
+INSERT INTO t2 VALUES ('{"a":1}', '{}');
+INSERT INTO t2 VALUES ('[1, {"a":1}]', '{}');
+INSERT INTO t2 VALUES ('[1, {"a":1}]', '{"a":1}');
+INSERT INTO t2 VALUES ('[{"abc":"def", "def":"abc"}]', '["foo","bar"]');
+INSERT INTO t2 VALUES ('[{"abc":"def", "def":"abc"}, "bar"]', '["bar", {}]');
+INSERT INTO t2 VALUES ('[{"a":"b"},{"c":"d"}]', '{"c":"d"}');
 
 SELECT
     j AS json,
@@ -64,7 +56,5 @@ FROM
     t2;
 
 DROP TABLE t2;
-
 DROP TABLE t1;
-
 DROP DATABASE json_contains_db;

mysql-test/columnstore/basic/t/func_json_contains_path.test

@@ -1,8 +1,8 @@
 --source ../include/have_columnstore.inc
 --disable_warnings
 DROP DATABASE IF EXISTS json_contains_path_db;
-
 --enable_warnings
+
 CREATE DATABASE json_contains_path_db;
 
 USE json_contains_path_db;
@@ -10,18 +10,16 @@ USE json_contains_path_db;
 --echo # ----------------------------------------------------------------------
 --echo # Test of JSON_CONTAINS_PATH function.
 --echo # ----------------------------------------------------------------------
+
 CREATE TABLE t1(j TEXT, r TEXT, p TEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-    t1
-VALUES
-    ('{"key1":1, "key2":[2,3]}', "oNE", "$.key2[1]"),
-    ('{"key1":1, "key2":[2,3]}', "oNE", "$.key2[10]"),
-    ('{"key1":1, "key2":[2,3]}', "oNE", "$.ma"),
-    ('{"key1":1, "key2":[2,3]}', "one", "$.key1"),
-    ('{ "a": true }', NULL, '$.a'),
-    ('{ "a": true }', 'all', NULL),
-    ('{"a":{"b":"c"}}', 'one', '$.a.*');
+INSERT INTO t1 VALUES ('{"key1":1, "key2":[2,3]}', "oNE", "$.key2[1]");
+INSERT INTO t1 VALUES ('{"key1":1, "key2":[2,3]}', "oNE", "$.key2[10]");
+INSERT INTO t1 VALUES ('{"key1":1, "key2":[2,3]}', "oNE", "$.ma");
+INSERT INTO t1 VALUES ('{"key1":1, "key2":[2,3]}', "one", "$.key1");
+INSERT INTO t1 VALUES ('{ "a": true }', NULL, '$.a');
+INSERT INTO t1 VALUES ('{ "a": true }', 'all', NULL);
+INSERT INTO t1 VALUES ('{"a":{"b":"c"}}', 'one', '$.a.*');
 
 SELECT
     j AS json,
@@ -33,27 +31,9 @@ FROM
 
 CREATE TABLE t2(j TEXT, r TEXT, p1 TEXT, p2 TEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-    t2
-VALUES
-    (
-        '{"key1":1, "key2":[2,3]}',
-        "one",
-        "$.key1",
-        "$.ma"
-    ),
-    (
-        '{"key1":1, "key2":[2,3]}',
-        "aLl",
-        "$.key1",
-        "$.ma"
-    ),
-    (
-        '{"key1":1, "key2":[2,3]}',
-        "aLl",
-        "$.key1",
-        "$.key2"
-    );
+INSERT INTO t2 VALUES ('{"key1":1, "key2":[2,3]}', "one", "$.key1", "$.ma");
+INSERT INTO t2 VALUES ('{"key1":1, "key2":[2,3]}', "aLl", "$.key1", "$.ma");
+INSERT INTO t2 VALUES ('{"key1":1, "key2":[2,3]}', "aLl", "$.key1", "$.key2");
 
 SELECT
     j AS json,
@@ -65,7 +45,5 @@ FROM
     t2;
 
 DROP TABLE t2;
-
 DROP TABLE t1;
-
 DROP DATABASE json_contains_path_db;

mysql-test/columnstore/basic/t/func_json_exists.test

@@ -1,8 +1,8 @@
 --source ../include/have_columnstore.inc
 --disable_warnings
 DROP DATABASE IF EXISTS json_exists_db;
-
 --enable_warnings
+
 CREATE DATABASE json_exists_db;
 
 USE json_exists_db;
@@ -11,27 +11,23 @@ USE json_exists_db;
 --echo # Test of JSON_EXISTS function.
 --echo # ----------------------------------------------------------------------
 --echo # Test case 0
+
 CREATE TABLE t1(j TEXT, p TEXT) ENGINE = columnstore;
 
-SET
-      @json = '{"key1":"xxxx", "key2":[1, 2, 3]}';
+SET @json = '{"key1":"xxxx", "key2":[1, 2, 3]}';
 
-INSERT INTO
-      t1
-VALUES
-      (@json, '$.key1'),
-      (@json, '$.key1[0]'),
-      (@json, '$.key2'),
-      (@json, '$.key2[1]'),
-      (@json, '$.key2[10]');
+INSERT INTO t1 VALUES (@json, '$.key1');
+INSERT INTO t1 VALUES (@json, '$.key1[0]');
+INSERT INTO t1 VALUES (@json, '$.key2');
+INSERT INTO t1 VALUES (@json, '$.key2[1]');
+INSERT INTO t1 VALUES (@json, '$.key2[10]');
 
 SELECT
-      j,
-      p,
-      JSON_EXISTS(j, p) AS result
+    j,
+    p,
+    JSON_EXISTS(j, p) AS result
 FROM
-      t1;
+    t1;
 
 DROP TABLE t1;
-
 DROP DATABASE json_exists_db;

mysql-test/columnstore/basic/t/func_json_extract.test

@@ -1,8 +1,8 @@
 --source ../include/have_columnstore.inc
 --disable_warnings
 DROP DATABASE IF EXISTS json_extract_db;
-
 --enable_warnings
+
 CREATE DATABASE json_extract_db;
 
 USE json_extract_db;
@@ -10,72 +10,58 @@ USE json_extract_db;
 --echo # ----------------------------------------------------------------------
 --echo # Test of JSON_EXTRACT function.
 --echo # ----------------------------------------------------------------------
+
 --echo 
 --echo # Single path expression
 --echo 
+
 CREATE TABLE t1(j LONGTEXT, p LONGTEXT) ENGINE = COLUMNSTORE;
 
-SET
-      @json = '[1, "val2", [3.1, -4]]';
+SET @json = '[1, "val2", [3.1, -4]]';
 
-INSERT INTO
-      t1
-VALUES
-      (@json, '$[0]'),
-      (@json, '$[1]'),
-      (@json, '$[2]'),
-      (@json, '$[3]'),
-      (@json, '$[2][0]'),
-      (@json, '$[2][1]'),
-      (@json, '$[2][10]'),
-      (@json, '$'),
-      ('1', '$'),
-      ('[10, 20, [30, 40], 1, 10]', '$[1]'),
-      ('{"key1":"asd", "key2":[2,3]}', "$.key1"),
-      ('{"key0":true, "key1":"qwe"}', "$.key1"),
-      ('[10, 20, [30, 40]]', '$[2][*]'),
-      ('[10, 20, [{"a":3}, 30, 40]]', '$[2][*]'),
-      (json_object('foo', 'foobar'), '$');
+INSERT INTO t1 VALUES (@json, '$[0]');
+INSERT INTO t1 VALUES (@json, '$[1]');
+INSERT INTO t1 VALUES (@json, '$[2]');
+INSERT INTO t1 VALUES (@json, '$[3]');
+INSERT INTO t1 VALUES (@json, '$[2][0]');
+INSERT INTO t1 VALUES (@json, '$[2][1]');
+INSERT INTO t1 VALUES (@json, '$[2][10]');
+INSERT INTO t1 VALUES (@json, '$');
+INSERT INTO t1 VALUES ('1', '$');
+INSERT INTO t1 VALUES ('[10, 20, [30, 40], 1, 10]', '$[1]');
+INSERT INTO t1 VALUES ('{"key1":"asd", "key2":[2,3]}', "$.key1");
+INSERT INTO t1 VALUES ('{"key0":true, "key1":"qwe"}', "$.key1");
+INSERT INTO t1 VALUES ('[10, 20, [30, 40]]', '$[2][*]');
+INSERT INTO t1 VALUES ('[10, 20, [{"a":3}, 30, 40]]', '$[2][*]');
+INSERT INTO t1 VALUES (json_object('foo', 'foobar'), '$');
 
 SELECT
-      j,
-      p,
-      JSON_EXTRACT(j, p) AS result
+    j,
+    p,
+    JSON_EXTRACT(j, p) AS result
 FROM
-      t1;
+    t1;
 
 --echo 
 --echo # Multiple path expression
 --echo 
+
 CREATE TABLE t2(j LONGTEXT, p1 LONGTEXT, p2 LONGTEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-      t2
-VALUES
-      (
-            '{"key1":"asd", "key2":[2,3]}',
-            "$.keyX",
-            "$.keyY"
-      ),
-      (
-            '{"key1":"asd", "key2":[2,3]}',
-            "$.key1",
-            "$.key2"
-      ),
-      ('{"key1":5, "key2":[2,3]}', "$.key1", "$.key2"),
-      ('[10, 20, [30, 40], 1, 10]', '$[1]', '$[25]'),
-      ('[{"a": [3, 4]}, {"b": 2}]', '$[0].a', '$[1].a');
+INSERT INTO t2 VALUES ('{"key1":"asd", "key2":[2,3]}', "$.keyX", "$.keyY");
+INSERT INTO t2 VALUES ('{"key1":"asd", "key2":[2,3]}', "$.key1", "$.key2");
+INSERT INTO t2 VALUES ('{"key1":5, "key2":[2,3]}', "$.key1", "$.key2");
+INSERT INTO t2 VALUES ('[10, 20, [30, 40], 1, 10]', '$[1]', '$[25]');
+INSERT INTO t2 VALUES ('[{"a": [3, 4]}, {"b": 2}]', '$[0].a', '$[1].a');
 
 SELECT
-      j,
-      p1,
-      p2,
-      JSON_EXTRACT(j, p1, p2) AS result
+    j,
+    p1,
+    p2,
+    JSON_EXTRACT(j, p1, p2) AS result
 FROM
-      t2;
+    t2;
 
 DROP TABLE t2;
-
 DROP TABLE t1;
-
 DROP DATABASE json_extract_db;

mysql-test/columnstore/basic/t/func_json_insert.test

@@ -1,8 +1,8 @@
 --source ../include/have_columnstore.inc
 --disable_warnings
 DROP DATABASE IF EXISTS json_insert_de;
-
 --enable_warnings
+
 CREATE DATABASE json_insert_de;
 
 USE json_insert_de;
@@ -10,36 +10,18 @@ USE json_insert_de;
 --echo # ----------------------------------------------------------------------
 --echo # Test of JSON_INSERT|REPLACE|SET function.
 --echo # ----------------------------------------------------------------------
+
 CREATE TABLE t1(j TEXT, p TEXT, v TEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-    t1
-VALUES
-    (
-        '{"a":1, "b":{"c":1}, "d":[1, 2]}',
-        '$.b.k1',
-        'word'
-    ),
-    ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.d[3]', 3),
-    ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.a[2]', 2),
-    (
-        '{"a":1, "b":{"c":1}, "d":[1, 2]}',
-        '$.b.c',
-        'word'
-    ),
-    ('1', '$[0]', 4),
-    ('[]', '$[0][0]', 100),
-    ('1', '$[0][0]', 100),
-    (
-        '{ "a": 1, "b": [2, 3]}',
-        '$.a',
-        10
-    ),
-    (
-        '{ "a": 1, "b": [2, 3]}',
-        '$.b',
-        '[true, false]'
-    );
+INSERT INTO t1 VALUES ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.b.k1', 'word');
+INSERT INTO t1 VALUES ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.d[3]', 3);
+INSERT INTO t1 VALUES ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.a[2]', 2);
+INSERT INTO t1 VALUES ('{"a":1, "b":{"c":1}, "d":[1, 2]}', '$.b.c', 'word');
+INSERT INTO t1 VALUES ('1', '$[0]', 4);
+INSERT INTO t1 VALUES ('[]', '$[0][0]', 100);
+INSERT INTO t1 VALUES ('1', '$[0][0]', 100);
+INSERT INTO t1 VALUES ('{ "a": 1, "b": [2, 3]}', '$.a', 10);
+INSERT INTO t1 VALUES ('{ "a": 1, "b": [2, 3]}', '$.b', '[true, false]');
 
 SELECT
     j AS json,
@@ -52,5 +34,4 @@ FROM
     t1;
 
 DROP TABLE t1;
-
 DROP DATABASE json_insert_de;

mysql-test/columnstore/basic/t/func_json_merge_patch.test

@@ -1,54 +1,64 @@
 DROP DATABASE IF EXISTS json_merge_patch_db;
 CREATE DATABASE json_merge_patch_db;
 USE json_merge_patch_db;
+
 # ----------------------------------------------------------------------
 # Test of JSON_MERGE_PATCH function.
 # ----------------------------------------------------------------------
+
 CREATE TABLE t1(l1 TEXT, l2 TEXT) ENGINE = columnstore;
-INSERT INTO t1(l1, l2) VALUES
-('{"a":"b"}', '{"a":"c"}'),
-('{"a":"b"}', '{"b":"c"}'),
-('{"a":"b"}', '{"a":null}'),
-('{"a":"b", "b":"c"}', '{"a":null}'),
-('{"a":["b"]}', '{"a":"c"}'),
-('{"a":"c"}', '{"a":["b"]}'),
-('{"a": {"b":"c"}}', '{"a": {"b":"d", "c":null}}'),
-('{"a":[{"b":"c"}]}', '{"a": [1]}'),
-('["a","b"]', '["c","d"]'),
-('{"a":"b"}', '["c"]'),
-('{"a":"foo"}', 'null'),
-('{"a":"foo"}', '"bar"'),
-('{"e":null}', '{"a":1}'),
-('[1,2]', '{"a":"b", "c":null}'),
-('{}', '{"a":{"bb":{"ccc":null}}}'),
-(NULL, '{}'),
-('{}', NULL);
+
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b"}', '{"a":"c"}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b"}', '{"b":"c"}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b"}', '{"a":null}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b", "b":"c"}', '{"a":null}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":["b"]}', '{"a":"c"}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"c"}', '{"a":["b"]}');
+INSERT INTO t1(l1, l2) VALUES ('{"a": {"b":"c"}}', '{"a": {"b":"d", "c":null}}');
+INSERT INTO t1(l1, l2) VALUES ('{"a":[{"b":"c"}]}', '{"a": [1]}');
+INSERT INTO t1(l1, l2) VALUES ('["a","b"]', '["c","d"]');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"b"}', '["c"]');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"foo"}', 'null');
+INSERT INTO t1(l1, l2) VALUES ('{"a":"foo"}', '"bar"');
+INSERT INTO t1(l1, l2) VALUES ('{"e":null}', '{"a":1}');
+INSERT INTO t1(l1, l2) VALUES ('[1,2]', '{"a":"b", "c":null}');
+INSERT INTO t1(l1, l2) VALUES ('{}', '{"a":{"bb":{"ccc":null}}}');
+INSERT INTO t1(l1, l2) VALUES (NULL, '{}');
+INSERT INTO t1(l1, l2) VALUES ('{}', NULL);
+
 SELECT l1, l2,
        JSON_MERGE_PATCH(l1, l2) AS `l1 + l2`
 FROM t1;
+
 DROP TABLE t1;
 
 CREATE TABLE t2(l1 TEXT, l2 TEXT, l3 TEXT) ENGINE = columnstore;
-INSERT INTO t2 VALUES
-('{"a":"b"}', NULL, '{"c":"d"}'),
-(NULL, '[1,2,3]', '[4,5,6]'),
-(NULL, 'a', 'b'),
-('{"a":"b"}', '[1,2,3]', '{"c":null,"d":"e"}');
+
+INSERT INTO t2 VALUES ('{"a":"b"}', NULL, '{"c":"d"}');
+INSERT INTO t2 VALUES (NULL, '[1,2,3]', '[4,5,6]');
+INSERT INTO t2 VALUES (NULL, 'a', 'b');
+INSERT INTO t2 VALUES ('{"a":"b"}', '[1,2,3]', '{"c":null,"d":"e"}');
+
 SELECT l1, l2, l3,
        JSON_MERGE_PATCH(l1, l2, l3) AS merged
 FROM t2;
+
 DROP TABLE t2;
 
-
 CREATE TABLE t3(l1 TEXT, l2 TEXT) ENGINE = columnstore;
+
 --error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
 SELECT JSON_MERGE_PATCH() FROM t3;
-INSERT INTO t3(l1, l2) VALUES('{}', '{"a":"c"}');
+
+INSERT INTO t3(l1, l2) VALUES ('{}', '{"a":"c"}');
+
 --error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
 SELECT l1, JSON_MERGE_PATCH(l1) AS merged FROM t3;
-INSERT INTO t3(l1, l2) VALUES
-('{', '[1,2,3]'),
-('{"a":"b"}', '[1,');
+
+INSERT INTO t3(l1, l2) VALUES ('{', '[1,2,3]');
+INSERT INTO t3(l1, l2) VALUES ('{"a":"b"}', '[1,');
+
 SELECT l1, l2, JSON_MERGE_PATCH(l1, l2) AS merged FROM t3;
+
 DROP TABLE t3;
 DROP DATABASE json_merge_patch_db;

mysql-test/columnstore/basic/t/func_json_remove.test

@@ -12,13 +12,10 @@ USE json_remove_db;
 --echo # ----------------------------------------------------------------------
 CREATE TABLE t1(j TEXT, p TEXT) ENGINE = columnstore;
 
-INSERT INTO
-    t1
-VALUES
-    ('["a", ["b", "c"], "d"]', '$[0]'),
-    ('["a", ["b", "c"], "d"]', '$[1]'),
-    ('["a", ["b", "c"], "d"]', '$[1][0]'),
-    ('["a", ["b", "c"], "d"]', '$[0]');
+INSERT INTO t1 VALUES ('["a", ["b", "c"], "d"]', '$[0]');
+INSERT INTO t1 VALUES ('["a", ["b", "c"], "d"]', '$[1]');
+INSERT INTO t1 VALUES ('["a", ["b", "c"], "d"]', '$[1][0]');
+INSERT INTO t1 VALUES ('["a", ["b", "c"], "d"]', '$[0]');
 
 SELECT
     j AS json,
@@ -29,14 +26,11 @@ FROM
 
 CREATE TABLE t2(j TEXT, p TEXT) ENGINE = columnstore;
 
-INSERT INTO
-    t2
-VALUES
-    ('{"a": 1, "b": [2, 3]}', '$.a'),
-    ('{"a": 1, "b": [2, 3]}', '$.a[0]'),
-    ('{"a": 1, "b": [2, 3]}', '$.b'),
-    ('{"a": 1, "b": [2, 3]}', '$.b[0]'),
-    ('{"a": 1, "b": [2, 3]}', '$.b[1]');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.a');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.a[0]');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.b');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.b[0]');
+INSERT INTO t2 VALUES ('{"a": 1, "b": [2, 3]}', '$.b[1]');
 
 SELECT
     j AS json,

mysql-test/columnstore/basic/t/func_json_valid.test

@@ -16,23 +16,20 @@ USE json_valid_db;
 
 CREATE TABLE t1(l LONGTEXT) ENGINE = COLUMNSTORE;
 
-INSERT INTO
-    t1
-VALUES
-    ('123'),
-    ('-123'),
-    ('5000000000'),
-    ('-5000000000'),
-    ('1.23'),
-    ('"123"'),
-    ('true'),
-    ('false'),
-    ('null'),
-    ('{"address": "Trondheim"}'),
-    (JSON_OBJECT()),
-    (JSON_OBJECT(1, 2)),
-    (JSON_ARRAY()),
-    (JSON_ARRAY(1, 2));
+INSERT INTO t1 VALUES ('123');
+INSERT INTO t1 VALUES ('-123');
+INSERT INTO t1 VALUES ('5000000000');
+INSERT INTO t1 VALUES ('-5000000000');
+INSERT INTO t1 VALUES ('1.23');
+INSERT INTO t1 VALUES ('"123"');
+INSERT INTO t1 VALUES ('true');
+INSERT INTO t1 VALUES ('false');
+INSERT INTO t1 VALUES ('null');
+INSERT INTO t1 VALUES ('{"address": "Trondheim"}');
+INSERT INTO t1 VALUES (JSON_OBJECT());
+INSERT INTO t1 VALUES (JSON_OBJECT(1, 2));
+INSERT INTO t1 VALUES (JSON_ARRAY());
+INSERT INTO t1 VALUES (JSON_ARRAY(1, 2));
 
 SELECT
     l AS raw,
@@ -46,14 +43,11 @@ FROM
 --echo #
 TRUNCATE t1;
 
-INSERT INTO
-    t1
-VALUES
-    ('12 3'),
-    ('{key:value}'),
-    ('{key:value'),
-    ('[1,2,]'),
-    ('[1,2');
+INSERT INTO t1 VALUES ('12 3');
+INSERT INTO t1 VALUES ('{key:value}');
+INSERT INTO t1 VALUES ('{key:value');
+INSERT INTO t1 VALUES ('[1,2,]');
+INSERT INTO t1 VALUES ('[1,2');
 
 SELECT
     l AS raw,
@@ -67,13 +61,9 @@ FROM
 --echo #
 TRUNCATE t1;
 
-SET
-    NAMES 'ascii';
+SET NAMES 'ascii';
 
-INSERT INTO
-    t1
-VALUES
-    ('123');
+INSERT INTO t1 VALUES ('123');
 
 SELECT
     l AS raw,
@@ -82,18 +72,14 @@ SELECT
 FROM
     t1;
 
-SET
-    NAMES 'utf8';
+SET NAMES 'utf8';
 
 --echo #
 --echo # Bare NULL
 --echo #
 TRUNCATE t1;
 
-INSERT INTO
-    t1
-VALUES
-    (NULL);
+INSERT INTO t1 VALUES (NULL);
 
 SELECT
     JSON_VALID(l)
@@ -105,10 +91,7 @@ FROM
 --echo #
 TRUNCATE t1;
 
-INSERT INTO
-    t1
-VALUES
-    (UPPER('"abc"'));
+INSERT INTO t1 VALUES (UPPER('"abc"'));
 
 SELECT
     JSON_VALID(l)
@@ -120,31 +103,23 @@ FROM
 --echo #
 TRUNCATE t1;
 
-SET
-    NAMES 'latin1';
+SET NAMES 'latin1';
 
-INSERT INTO
-    t1
-VALUES
-    (UPPER('"abc"'));
+INSERT INTO t1 VALUES (UPPER('"abc"'));
 
 SELECT
     JSON_VALID(l)
 FROM
     t1;
 
-SET
-    NAMES 'utf8';
+SET NAMES 'utf8';
 
 --echo #
 --echo # Function result - date, not valid as JSON without CAST
 --echo #
 TRUNCATE t1;
 
-INSERT INTO
-    t1
-VALUES
-    (CAST('2015-01-15' AS DATE));
+INSERT INTO t1 VALUES (CAST('2015-01-15' AS DATE));
 
 SELECT
     JSON_VALID(l)
@@ -156,14 +131,11 @@ FROM
 --echo #
 TRUNCATE t1;
 
-INSERT INTO
-    t1
-VALUES
-    (
-        CAST(
-            CAST('2015-01-15' AS DATE) AS CHAR CHARACTER SET 'utf8'
-        )
-    );
+INSERT INTO t1 VALUES (
+    CAST(
+        CAST('2015-01-15' AS DATE) AS CHAR CHARACTER SET 'utf8'
+    )
+);
 
 SELECT
     JSON_VALID(l)
@@ -175,15 +147,8 @@ FROM
 --echo #
 TRUNCATE t1;
 
-INSERT INTO
-    t1
-VALUES
-    (UPPER(NULL));
-
-INSERT INTO
-    t1
-VALUES
-    (UPPER(CAST(NULL AS CHAR)));
+INSERT INTO t1 VALUES (UPPER(NULL));
+INSERT INTO t1 VALUES (UPPER(CAST(NULL AS CHAR)));
 
 SELECT
     JSON_VALID(l)

mysql-test/columnstore/basic/t/func_json_value.test

@@ -11,22 +11,26 @@ USE json_value_db;
 --echo # ----------------------------------------------------------------------
 
 CREATE TABLE t1(s TEXT, p TEXT) ENGINE = columnstore;
-INSERT INTO t1 VALUES('{"key1":123}', '$.key2'),
-('{"key1":123}', '$.key1'),
-('{"key1":[1,2,3]}', '$.key1'),
-('{"key1": [1,2,3], "key1":123}', '$.key1'),
-('{ "x": [0,1], "y": "[0,1]", "z": "Mon\\\"t\\\"y" }','$.z'),
-('{"\\"key1":123}', '$."\\"key1"'),
-('{"\\"key1\\"":123}', '$."\\"key1\\""'),
-('{"key 1":123}', '$."key 1"');
 
-SELECT s as json_text, p as path, JSON_VALUE(s, p) as json_value, JSON_QUERY(s, p) as json_query
+INSERT INTO t1 VALUES ('{"key1":123}', '$.key2');
+INSERT INTO t1 VALUES ('{"key1":123}', '$.key1');
+INSERT INTO t1 VALUES ('{"key1":[1,2,3]}', '$.key1');
+INSERT INTO t1 VALUES ('{"key1": [1,2,3], "key1":123}', '$.key1');
+INSERT INTO t1 VALUES ('{ "x": [0,1], "y": "[0,1]", "z": "Mon\\\"t\\\"y" }', '$.z');
+INSERT INTO t1 VALUES ('{"\\"key1":123}', '$."\\"key1"');
+INSERT INTO t1 VALUES ('{"\\"key1\\"":123}', '$."\\"key1\\""');
+INSERT INTO t1 VALUES ('{"key 1":123}', '$."key 1"');
+
+SELECT s AS json_text, p AS path,
+       JSON_VALUE(s, p) AS json_value,
+       JSON_QUERY(s, p) AS json_query
 FROM t1;
 
 CREATE TABLE t2(s TEXT) ENGINE = columnstore;
-INSERT INTO t2 VALUES('{"key1":123, "key2":{"key3":"value3"}}'),
-('{"key1":123, "key3":[1,2,3]}'),
-('{"key1":123, "key2":"[1]"}');
+
+INSERT INTO t2 VALUES ('{"key1":123, "key2":{"key3":"value3"}}');
+INSERT INTO t2 VALUES ('{"key1":123, "key3":[1,2,3]}');
+INSERT INTO t2 VALUES ('{"key1":123, "key2":"[1]"}');
 
 SELECT s as json_text, '$.key1' , JSON_VALUE(s, '$.key1') as json_value, JSON_QUERY(s, '$.key1') as json_query
 FROM t2;
@@ -42,7 +46,17 @@ DROP TABLE t1;
 
 # check an absence of race bug in json_query.
 CREATE TABLE zu (hu TEXT) ENGINE = COLUMNSTORE;
-INSERT INTO zu(hu) VALUES ('{}'), (NULL), ('{ "": "huh", "10001" : "10001", "10002" : "10001", "10003" : "10001", "10004" : "10001", "10005" : "10001", "10006" : "10001", "10007" : "10001", "10008" : "10001", "10009" : "10001", "10010" : "10001", "10011" : "10001", "10012" : "10001", "10013" : "10001", "10014" : "10001", "10015" : "10001", "10016" : "10001", "10017" : "10001", "10018" : "10001", "10019" : "10001", "10020" : "10001", "buga" : ""}');
+
+INSERT INTO zu(hu) VALUES ('{}');
+INSERT INTO zu(hu) VALUES (NULL);
+INSERT INTO zu(hu) VALUES (
+  '{ "": "huh", "10001" : "10001", "10002" : "10001", "10003" : "10001", "10004" : "10001",
+     "10005" : "10001", "10006" : "10001", "10007" : "10001", "10008" : "10001", "10009" : "10001",
+     "10010" : "10001", "10011" : "10001", "10012" : "10001", "10013" : "10001", "10014" : "10001",
+     "10015" : "10001", "10016" : "10001", "10017" : "10001", "10018" : "10001", "10019" : "10001",
+     "10020" : "10001", "buga" : "" }'
+);
+
 INSERT INTO zu(hu) SELECT hu FROM zu;
 INSERT INTO zu(hu) SELECT hu FROM zu;
 INSERT INTO zu(hu) SELECT hu FROM zu;

mysql-test/columnstore/basic/t/func_jsonarrayagg.test

@@ -6,7 +6,14 @@ USE json_arrayagg_db;
 
 
 CREATE TABLE t1 (a INT, b INT)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1, 1),(2, 1), (1, 1),(2, 1), (3, 2),(2, 2),(2, 2),(2, 2);
+INSERT INTO t1 VALUES (1, 1);
+INSERT INTO t1 VALUES (2, 1);
+INSERT INTO t1 VALUES (1, 1);
+INSERT INTO t1 VALUES (2, 1);
+INSERT INTO t1 VALUES (3, 2);
+INSERT INTO t1 VALUES (2, 2);
+INSERT INTO t1 VALUES (2, 2);
+INSERT INTO t1 VALUES (2, 2);
 SELECT JSON_VALID(JSON_ARRAYAGG(a)) FROM t1;
 sorted_result;
 SELECT JSON_ARRAYAGG(a), JSON_ARRAYAGG(b) FROM t1;
@@ -18,7 +25,10 @@ DROP TABLE t1;
 -- echo # Real aggregation
 -- echo #
 CREATE TABLE t1 (a FLOAT, b DOUBLE, c DECIMAL(10, 2))ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1.0, 2.0, 3.0),(1.0, 3.0, 9.0),(1.0, 4.0, 16.0),(1.0, 5.0, 25.0);
+INSERT INTO t1 VALUES (1.0, 2.0, 3.0);
+INSERT INTO t1 VALUES (1.0, 3.0, 9.0);
+INSERT INTO t1 VALUES (1.0, 4.0, 16.0);
+INSERT INTO t1 VALUES (1.0, 5.0, 25.0);
 SELECT JSON_VALID(JSON_ARRAYAGG(a)) FROM t1;
 sorted_result;
 SELECT JSON_ARRAYAGG(a), JSON_ARRAYAGG(b), JSON_ARRAYAGG(c) FROM t1;
@@ -28,7 +38,10 @@ DROP TABLE t1;
 -- echo # Boolean aggregation
 -- echo #
 CREATE TABLE t1 (a BOOLEAN, b BOOLEAN)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (TRUE, TRUE), (TRUE, FALSE), (FALSE, TRUE), (FALSE, FALSE);
+INSERT INTO t1 VALUES (TRUE, TRUE);
+INSERT INTO t1 VALUES (TRUE, FALSE);
+INSERT INTO t1 VALUES (FALSE, TRUE);
+INSERT INTO t1 VALUES (FALSE, FALSE);
 SELECT JSON_VALID(JSON_ARRAYAGG(a)) FROM t1;
 sorted_result;
 SELECT JSON_ARRAYAGG(a), JSON_ARRAYAGG(b) FROM t1;
@@ -42,9 +55,10 @@ DROP TABLE t1;
 -- echo # Aggregation of strings with quoted
 -- echo #
 CREATE TABLE t1 (a VARCHAR(80))ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES
-       ('"double_quoted_value"'), ("'single_quoted_value'"),
-       ('"double_quoted_value"'), ("'single_quoted_value'");
+INSERT INTO t1 VALUES ('"double_quoted_value"');
+INSERT INTO t1 VALUES ("'single_quoted_value'");
+INSERT INTO t1 VALUES ('"double_quoted_value"');
+INSERT INTO t1 VALUES ("'single_quoted_value'");
 SELECT JSON_VALID(JSON_ARRAYAGG(a)) FROM t1;
 sorted_result;
 SELECT JSON_ARRAYAGG(a) FROM t1;
@@ -54,9 +68,20 @@ DROP TABLE t1;
 -- echo # Strings and NULLs
 -- echo #
 CREATE TABLE t1 (a INT, b VARCHAR(80))ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES
-       (1, "Hello"),(1, "World"), (2, "This"),(2, "Will"), (2, "Work"),(2, "!"), (3, NULL),
-       (1, "Hello"),(1, "World"), (2, "This"),(2, "Will"), (2, "Work"),(2, "!"), (3, NULL);
+INSERT INTO t1 VALUES (1, "Hello");
+INSERT INTO t1 VALUES (1, "World");
+INSERT INTO t1 VALUES (2, "This");
+INSERT INTO t1 VALUES (2, "Will");
+INSERT INTO t1 VALUES (2, "Work");
+INSERT INTO t1 VALUES (2, "!");
+INSERT INTO t1 VALUES (3, NULL);
+INSERT INTO t1 VALUES (1, "Hello");
+INSERT INTO t1 VALUES (1, "World");
+INSERT INTO t1 VALUES (2, "This");
+INSERT INTO t1 VALUES (2, "Will");
+INSERT INTO t1 VALUES (2, "Work");
+INSERT INTO t1 VALUES (2, "!");
+INSERT INTO t1 VALUES (3, NULL);
 SELECT JSON_VALID(JSON_ARRAYAGG(b)) FROM t1;
 sorted_result;
 SELECT JSON_ARRAYAGG(a), JSON_ARRAYAGG(b) FROM t1;
@@ -75,13 +100,13 @@ SELECT JSON_ARRAYAGG(b LIMIT 1) FROM t1 GROUP BY b;
 sorted_result;
 SELECT JSON_ARRAYAGG(b LIMIT 2) FROM t1 GROUP BY a;
 sorted_result;
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
+## SELECT JSON_ARRAYAGG(DISTINCT a) FROM t1;
 sorted_result;
-SELECT JSON_ARRAYAGG(DISTINCT b ORDER BY b ASC) FROM t1;
+## SELECT JSON_ARRAYAGG(DISTINCT b) FROM t1;
 sorted_result;
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC LIMIT 2) FROM t1;
+# SELECT JSON_ARRAYAGG(DISTINCT a LIMIT 2) FROM t1;
 sorted_result;
-SELECT JSON_ARRAYAGG(DISTINCT b ORDER BY b ASC LIMIT 2) FROM t1;
+## SELECT JSON_ARRAYAGG(DISTINCT b LIMIT 2) FROM t1;
 
 -- echo #
 -- echo # JSON aggregation
@@ -113,10 +138,8 @@ SELECT JSON_ARRAYAGG(JSON_ARRAYAGG(a)) FROM t1;
 -- echo #
 -- echo #
 
-
 DROP TABLE t1;
 
-
 -- echo #
 -- echo #
 
@@ -151,35 +174,45 @@ select json_object('x', json_arrayagg(json_object('a', 1)));
 --echo #
 
 CREATE TABLE t1(a INT, b INT)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1,1), (2,2), (3,3);
-INSERT INTO t1 VALUES (1,1), (2,2), (3,3);
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t1 VALUES (2,2);
+INSERT INTO t1 VALUES (3,3);
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t1 VALUES (2,2);
+INSERT INTO t1 VALUES (3,3);
 sorted_result;
 SELECT JSON_ARRAYAGG(a) FROM t1;
 sorted_result;
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
+## SELECT JSON_ARRAYAGG(DISTINCT a) FROM t1;
 
-INSERT INTO t1 VALUES (NULL,NULL), (NULL,NULL);
+INSERT INTO t1 VALUES (NULL,NULL);
+INSERT INTO t1 VALUES (NULL,NULL);
 
 sorted_result;
 SELECT JSON_ARRAYAGG(a) FROM t1;
 sorted_result;
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
+## SELECT JSON_ARRAYAGG(DISTINCT a) FROM t1;
 DROP TABLE t1;
 
 CREATE TABLE t1(a VARCHAR(10), b INT)ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES (1,1), (2,2), (3,3);
-INSERT INTO t1 VALUES (1,1), (2,2), (3,3);
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t1 VALUES (2,2);
+INSERT INTO t1 VALUES (3,3);
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t1 VALUES (2,2);
+INSERT INTO t1 VALUES (3,3);
 
 sorted_result;
 SELECT JSON_ARRAYAGG(a) FROM t1;
 sorted_result;
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
+## SELECT JSON_ARRAYAGG(DISTINCT a) FROM t1;
 
-INSERT INTO t1 VALUES (NULL,NULL), (NULL,NULL);
+INSERT INTO t1 VALUES (NULL,NULL);
+INSERT INTO t1 VALUES (NULL,NULL);
 sorted_result;
 SELECT JSON_ARRAYAGG(a) FROM t1;
 sorted_result;
-SELECT JSON_ARRAYAGG(DISTINCT a ORDER BY a ASC) FROM t1;
+## SELECT JSON_ARRAYAGG(DISTINCT a) FROM t1;
 
 DROP TABLE t1;
 
@@ -187,7 +220,8 @@ DROP TABLE t1;
 --echo #
 
 CREATE TABLE t1(a VARCHAR(255))ENGINE=COLUMNSTORE;
-INSERT INTO t1 VALUES ('red'),('blue');
+INSERT INTO t1 VALUES ('red');
+INSERT INTO t1 VALUES ('blue');
 
 sorted_result;
 SELECT JSON_ARRAYAGG(a) FROM t1;
@@ -204,7 +238,8 @@ DROP TABLE t1;
 set group_concat_max_len=64;
 create table t1 (a varchar(254))ENGINE=COLUMNSTORE;
 insert into t1 values (concat('x64-', repeat('a', 60)));
-insert into t1 values (concat('x64-', repeat('b', 60)));                                            insert into t1 values (concat('x64-', repeat('c', 60)));
+insert into t1 values (concat('x64-', repeat('b', 60)));
+insert into t1 values (concat('x64-', repeat('c', 60)));
 sorted_result;
 select json_arrayagg(a) from t1;
 drop table t1;
@@ -215,8 +250,13 @@ SET group_concat_max_len= default;
 CREATE TABLE t1(id int, name varchar(50))ENGINE=COLUMNSTORE;
 CREATE TABLE t2(id int, owner_id int)ENGINE=COLUMNSTORE;
 
-INSERT INTO t1 VALUES (1, "name1"), (2, "name2"), (3, "name3");
-INSERT INTO t2 VALUES (1, 1), (2, 1), (3, 2), (4, 3);
+INSERT INTO t1 VALUES (1, "name1");
+INSERT INTO t1 VALUES (2, "name2");
+INSERT INTO t1 VALUES (3, "name3");
+INSERT INTO t2 VALUES (1, 1);
+INSERT INTO t2 VALUES (2, 1);
+INSERT INTO t2 VALUES (3, 2);
+INSERT INTO t2 VALUES (4, 3);
 
 SELECT t1.id, JSON_ARRAYAGG(JSON_OBJECT('id',t2.id) ORDER BY t2.id) as materials
   from t1 LEFT JOIN t2 on t1.id = t2.owner_id
@@ -237,7 +277,8 @@ SELECT json_object('a', coalesce(json_object('b', 'c')));
 
 CREATE TABLE t (a VARCHAR(8))ENGINE=COLUMNSTORE;
 CREATE VIEW v AS SELECT * FROM t;
-INSERT INTO t VALUES ('foo'),('bar');
+INSERT INTO t VALUES ('foo');
+INSERT INTO t VALUES ('bar');
 sorted_result;
 SELECT JSON_ARRAYAGG(a) AS f FROM v;
 DROP VIEW v;