database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-07-29 08:21:15 +03:00
Code Activity

MCOL-785 Implement DISTRIBUTED JSON functions

Browse Source 
The following functions are created:
Create function JSON_VALID and test cases
Create function JSON_DEPTH and test cases
Create function JSON_LENGTH and test cases
Create function JSON_EQUALS and test cases
Create function JSON_NORMALIZE and test cases
Create function JSON_TYPE and test cases
Create function JSON_OBJECT and test cases
Create function JSON_ARRAY and test cases
Create function JSON_KEYS and test cases
Create function JSON_EXISTS and test cases
Create function JSON_QUOTE/JSON_UNQUOTE and test cases
Create function JSON_COMPACT/DETAILED/LOOSE and test cases
Create function JSON_MERGE and test cases
Create function JSON_MERGE_PATCH and test cases
Create function JSON_VALUE and test cases
Create function JSON_QUERY and test cases
Create function JSON_CONTAINS and test cases
Create function JSON_ARRAY_APPEND and test cases
Create function JSON_ARRAY_INSERT and test cases
Create function JSON_INSERT/REPLACE/SET and test cases
Create function JSON_REMOVE and test cases
Create function JSON_CONTAINS_PATH and test cases
Create function JSON_OVERLAPS and test cases
Create function JSON_EXTRACT and test cases
Create function JSON_SEARCH and test cases

Note:
Some functions output differs from MDB because session variables that affects functions output,e.g JSON_QUOTE/JSON_UNQUOTE
This depends on MCOL-5212
This commit is contained in:
Ziy1-Tan
2022-06-23 10:49:29 +08:00
parent b5d8e0324b
commit cdd41f05f3
82 changed files with 8645 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
mysql-test/columnstore/basic/t/func_json_array.test Normal file
View File

@ -0,0 +1,21 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_array_db;
--enable_warnings
CREATE DATABASE json_array_db;
USE json_array_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_ARRAY function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l text) ENGINE = COLUMNSTORE;
INSERT INTO t1 VALUES('1');
SELECT JSON_ARRAY() FROM t1;
SELECT JSON_ARRAY(l) FROM t1;
SELECT JSON_ARRAY(l, null, 'My name is "Foo"', 3.1415, 6) FROM t1;
SELECT JSON_ARRAY(l, true, false, "true", "false") FROM t1;
SELECT JSON_ARRAY(l, '{"key1":"value1"}') FROM t1;
SELECT JSON_ARRAY(l, JSON_COMPACT( '{"key1":"value1"}' ) ) FROM t1;
DROP TABLE t1;
DROP DATABASE json_array_db;

97
mysql-test/columnstore/basic/t/func_json_array_append.test Normal file
View File

@ -0,0 +1,97 @@
--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;
--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'
);
SELECT
a AS arrary,
p AS path,
v AS value,
JSON_ARRAY_APPEND(a, p, v) AS result
FROM
t1;
--echo # NULL args
CREATE TABLE t2(a TEXT) ENGINE = COLUMNSTORE;
INSERT INTO
t2
VALUES
('[1,2,3]');
SELECT
JSON_ARRAY_APPEND(a, NULL, JSON_COMPACT(1)),
JSON_ARRAY_APPEND(a, '$', NULL)
FROM
t2;
TRUNCATE t2;
INSERT INTO
t2
VALUES
('$.b');
SELECT
JSON_ARRAY_APPEND(NULL, a, JSON_COMPACT(1)),
JSON_ARRAY_APPEND('[1,2,3]', a, NULL)
FROM
t2;
TRUNCATE t2;
INSERT INTO
t2
VALUES
('$**[0]');
--echo error ER_INVALID_JSON_PATH_WILDCARD
SELECT
JSON_ARRAY_APPEND(JSON_COMPACT('{"a": {"b": [3]}}'), a, 6)
FROM
t2;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_array_append_db;

97
mysql-test/columnstore/basic/t/func_json_array_insert.test Normal file
View File

@ -0,0 +1,97 @@
--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;
--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'
);
SELECT
a AS arrary,
p AS path,
v AS value,
JSON_ARRAY_INSERT(a, p, v) AS result
FROM
t1;
--echo # NULL args
CREATE TABLE t2(a TEXT) ENGINE = COLUMNSTORE;
INSERT INTO
t2
VALUES
('[1,2,3]');
SELECT
JSON_ARRAY_INSERT(a, NULL, JSON_COMPACT(1)),
JSON_ARRAY_INSERT(a, '$', NULL)
FROM
t2;
TRUNCATE t2;
INSERT INTO
t2
VALUES
('$.b');
SELECT
JSON_ARRAY_INSERT(NULL, a, JSON_COMPACT(1)),
JSON_ARRAY_INSERT('[1,2,3]', a, NULL)
FROM
t2;
TRUNCATE t2;
INSERT INTO
t2
VALUES
('$**[0]');
--echo error ER_INVALID_JSON_PATH_WILDCARD
SELECT
JSON_ARRAY_INSERT(JSON_COMPACT('{"a": {"b": [3]}}'), a, 6)
FROM
t2;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_array_insert_db;

70
mysql-test/columnstore/basic/t/func_json_contains.test Normal file
View File

@ -0,0 +1,70 @@
--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;
--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', '$');
SELECT
j AS json,
v AS value,
p AS path,
JSON_CONTAINS(j, v, p) AS result
FROM
t1;
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"}');
SELECT
j AS json,
v AS value,
JSON_CONTAINS(j, v) AS result
FROM
t2;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_contains_db;

71
mysql-test/columnstore/basic/t/func_json_contains_path.test Normal file
View File

@ -0,0 +1,71 @@
--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;
--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.*');
SELECT
j AS json,
r AS return_flag,
p AS path,
JSON_CONTAINS_PATH(j, r, p) AS result
FROM
t1;
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"
);
SELECT
j AS json,
r AS return_flag,
p1 AS path,
p2 AS path,
JSON_CONTAINS_PATH(j, r, p1, p2) AS result
FROM
t2;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_contains_path_db;

45
mysql-test/columnstore/basic/t/func_json_depth.test Normal file
View File

@ -0,0 +1,45 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_depth_db;
--enable_warnings
CREATE DATABASE json_depth_db;
USE json_depth_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_DEPTH function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l LONGTEXT) ENGINE = columnstore;
--echo # Return NULL
INSERT INTO t1 VALUES(NULL);
SELECT JSON_DEPTH(l) FROM t1;
--echo # Return 1
TRUNCATE t1;
INSERT INTO t1 VALUES('{}');
INSERT INTO t1 VALUES('[]');
INSERT INTO t1 VALUES('"abc"');
SELECT JSON_DEPTH(l) FROM t1;
--echo # Error ER_INVALID_TYPE_FOR_JSON
CREATE TABLE t2(i int) ENGINE=columnstore;
INSERT INTO t2 VALUES(1);
SELECT JSON_DEPTH(i) FROM t2;
DROP TABLE t2;
--echo # Error ER_INVALID_JSON_TEXT_IN_PARAM
TRUNCATE t1;
INSERT INTO t1 VALUES('abc');
INSERT INTO t1 VALUES('[ "a", true, "b" , { "e" : false }, "c" , null');
SELECT JSON_DEPTH(l) FROM t1;
--echo # Return 2
TRUNCATE t1;
INSERT INTO t1 VALUES('{ "a" : true, "b" : false, "c" : null }');
INSERT INTO t1 VALUES('[ "a", true, "b" , false, "c" , null ]');
INSERT INTO t1 VALUES('{ "a" : true, "b" : {}, "c" : null }');
INSERT INTO t1 VALUES('[ "a", true, "b" , {}, "c" , null ]');
SELECT JSON_DEPTH(l) FROM t1;
--echo # Return 3
TRUNCATE t1;
INSERT INTO t1 VALUES('{ "a" : true, "b" : { "e" : false }, "c" : null }');
SELECT JSON_DEPTH(l) FROM t1;
DROP TABLE t1;
DROP DATABASE json_depth_db;

34
mysql-test/columnstore/basic/t/func_json_equals.test Normal file
View File

@ -0,0 +1,34 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_equals_db;
--enable_warnings
CREATE DATABASE json_equals_db;
USE json_equals_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_EQUALS function.
--echo # ----------------------------------------------------------------------
--echo # Return 1
CREATE TABLE t1(l LONGTEXT, r LONGTEXT) ENGINE = columnstore;
INSERT INTO t1 VALUES('{"a":1,"b":2}','{"a":1,"b":2}');
INSERT INTO t1 VALUES('{"a":1,"b":2}','{"b":2,"a":1}');
INSERT INTO t1 VALUES('{"a":1,"b":2}','{"a": 1,"b": 2}');
INSERT INTO t1 VALUES('{"a": 1,"b":2}','{"b":2,"a":1}');
INSERT INTO t1 VALUES('[1,2]','[1,2]');
INSERT INTO t1 VALUES('[1,2]','[1 , 2]');
INSERT INTO t1 VALUES(1,1);
SELECT JSON_EQUALS(l, r) FROM t1;
--echo # Return 0
TRUNCATE t1;
INSERT INTO t1 VALUES('{"a":1,"b":3}','{"a":1,"b":2}');
INSERT INTO t1 VALUES('[1,2]','[2,1]');
INSERT INTO t1 VALUES(1,2);
SELECT JSON_EQUALS(l, r) FROM t1;
--echo # NULL
TRUNCATE t1;
INSERT INTO t1 VALUES('["a",true,{"e":false},null','["a",true,{"e":false},null');
INSERT INTO t1 VALUES('s1',"s1");
SELECT JSON_EQUALS(l, r) FROM t1;
DROP TABLE t1;
DROP DATABASE json_equals_db;

37
mysql-test/columnstore/basic/t/func_json_exists.test Normal file
View File

@ -0,0 +1,37 @@
--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;
--echo # ----------------------------------------------------------------------
--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]}';
INSERT INTO
t1
VALUES
(@json, '$.key1'),
(@json, '$.key1[0]'),
(@json, '$.key2'),
(@json, '$.key2[1]'),
(@json, '$.key2[10]');
SELECT
j,
p,
JSON_EXISTS(j, p) AS result
FROM
t1;
DROP TABLE t1;
DROP DATABASE json_exists_db;

81
mysql-test/columnstore/basic/t/func_json_extract.test Normal file
View File

@ -0,0 +1,81 @@
--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;
--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]]';
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'), '$');
SELECT
j,
p,
JSON_EXTRACT(j, p) AS result
FROM
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');
SELECT
j,
p1,
p2,
JSON_EXTRACT(j, p1, p2) AS result
FROM
t2;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_extract_db;

56
mysql-test/columnstore/basic/t/func_json_insert.test Normal file
View File

@ -0,0 +1,56 @@
--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;
--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]'
);
SELECT
j AS json,
p AS path,
v AS value,
JSON_INSERT(j, p, v) AS json_insert,
JSON_REPLACE(j, p, v) AS json_replace,
JSON_SET(j, p, v) AS json_set
FROM
t1;
DROP TABLE t1;
DROP DATABASE json_insert_de;

21
mysql-test/columnstore/basic/t/func_json_keys.test Normal file
View File

@ -0,0 +1,21 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_keys_db;
--enable_warnings
CREATE DATABASE json_keys_db;
USE json_keys_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_KEYS function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l TEXT) ENGINE = columnstore;
INSERT INTO t1 VALUES('{"key1":"value1", "key2":{"key3": "value2"}}');
INSERT INTO t1 VALUES('{"key1":"value1", "key2":{"key3": "value3", "key4":"value4"}}');
INSERT INTO t1 VALUES('{"key1":"value1" "key2":{"key3": "value3", "key4":"value4"}}');
SELECT JSON_KEYS(l) from t1;
SELECT JSON_KEYS(l, '$.key2') from t1;
SELECT JSON_KEYS(l, '$.key1') from t1;
SELECT JSON_KEYS(l, '$.key123') from t1;
DROP TABLE t1;
DROP DATABASE json_keys_db;

81
mysql-test/columnstore/basic/t/func_json_length.test Normal file
View File

@ -0,0 +1,81 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_length_db;
--enable_warnings
CREATE DATABASE json_length_db;
USE json_length_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_LENGTH function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l LONGTEXT) ENGINE = columnstore;
--echo # Invalid json text
INSERT INTO t1 VALUES(null);
INSERT INTO t1 VALUES('1');
INSERT INTO t1 VALUES('abc');
INSERT INTO t1 VALUES('"abc"');
INSERT INTO t1 VALUES('true');
INSERT INTO t1 VALUES('false');
INSERT INTO t1 VALUES('null');
--echo error ER_INVALID_JSON_TEXT_IN_PARAM
SELECT JSON_LENGTH(l) FROM t1;
--echo # Valid json text
TRUNCATE t1;
INSERT INTO t1 VALUES('{}');
INSERT INTO t1 VALUES('{ "a" : 100, "b" : 200 }');
INSERT INTO t1 VALUES('{ "a" : 100, "b" : [ 300, 400, 500 ] }');
INSERT INTO t1 VALUES('[]');
INSERT INTO t1 VALUES('[ null, "foo", true, 1.1 ]');
INSERT INTO t1 VALUES('[ null, "foo", true, { "a" : "b", "c" : "d" } ]');
INSERT INTO t1 VALUES('"foo"');
INSERT INTO t1 VALUES('1.2');
SELECT JSON_LENGTH(l) FROM t1;
--echo # Bad path expressions
TRUNCATE t1;
INSERT INTO t1 VALUES('true');
--echo error ER_INVALID_JSON_PATH
SELECT JSON_LENGTH(l, 'c$') FROM t1;
TRUNCATE t1;
INSERT INTO t1 VALUES('{ "foo" : [ true, false ] }');
--echo error ER_INVALID_JSON_PATH
SELECT JSON_LENGTH(l, '$.foo[bar]') FROM t1;
--echo # wildcards not allowed in path expressions for this function
TRUNCATE t1;
INSERT INTO t1 VALUES('true');
--echo error ER_INVALID_JSON_PATH_WILDCARD
SELECT JSON_LENGTH(l, '$.*') FROM t1;
TRUNCATE t1;
INSERT INTO t1 VALUES('true');
--echo error ER_INVALID_JSON_PATH_WILDCARD
SELECT JSON_LENGTH(l, '$.foo**.bar') FROM t1;
--echo # Error ER_INVALID_JSON_TEXT_IN_PARAM
TRUNCATE t1;
INSERT INTO t1 VALUES('abc');
INSERT INTO t1 VALUES('[ "a", true, "b" , { "e" : false }, "c" , null');
SELECT JSON_LENGTH(l) FROM t1;
--echo # Path exist
TRUNCATE t1;
INSERT INTO t1 VALUES('[ 1, [ 2, 3, 4 ], 5 ]');
SELECT JSON_LENGTH(l, '$[0]') FROM t1;
SELECT JSON_LENGTH(l, '$[1]') FROM t1;
SELECT JSON_LENGTH(l, '$[2]') FROM t1;
SELECT JSON_LENGTH(l, '$[2][0]') FROM t1;
TRUNCATE t1;
INSERT INTO t1 VALUES('[ 1, [ 2, 3, 4 ], {"a": 1} ]');
SELECT JSON_LENGTH(l, '$[2][0]') FROM t1;
TRUNCATE t1;
INSERT INTO t1 VALUES('[ 1, { "a": true, "b": false, "c": null }, 5 ]');
SELECT JSON_LENGTH(l, '$[1]') FROM t1;
TRUNCATE t1;
INSERT INTO t1 VALUES('{ "a" : 123, "b" : [ 123, 456, 789 ] }');
SELECT JSON_LENGTH(l) FROM t1;
SELECT JSON_LENGTH(l, '$.b') FROM t1;
SELECT JSON_LENGTH(l, '$.c') FROM t1;
--echo # No-existent path
TRUNCATE t1;
INSERT INTO t1 VALUES('[ 1, [ 2, 3, 4 ], 5 ]');
SELECT JSON_LENGTH(l, '$[2][1]') FROM t1;
DROP TABLE t1;
DROP DATABASE json_length_db;

79
mysql-test/columnstore/basic/t/func_json_merge.test Normal file
View File

@ -0,0 +1,79 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_merge_db;
--enable_warnings
CREATE DATABASE json_merge_db;
USE json_merge_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_MERGE function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l TEXT, r TEXT) ENGINE = columnstore;
INSERT INTO t1 VALUES('[1, 2, 3]','[4, 5, 6]');
--echo # Not enough args
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT JSON_MERGE() FROM t1;
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT JSON_MERGE(l) FROM t1;
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT JSON_MERGE(NULL) FROM t1;
--echo # Null args
SELECT JSON_MERGE(NULL, r) FROM t1;
SELECT JSON_MERGE(l, NULL) FROM t1;
SELECT JSON_MERGE(NULL, l, r) FROM t1;
SELECT JSON_MERGE(l, NULL, r) FROM t1;
SELECT JSON_MERGE(l, r, NULL) FROM t1;
--echo # Invalid JSON text
--echo error ER_INVALID_JSON_TEXT_IN_PARAM
SELECT JSON_MERGE(l, '[4, 5, 6') FROM t1;
--echo error ER_INVALID_JSON_TEXT_IN_PARAM
SELECT JSON_MERGE('[1, 2, 3', r) FROM t1;
--echo # Good JSON_MERGE() Expressions
TRUNCATE t1;
INSERT INTO t1 VALUES('1', '2' );
INSERT INTO t1 VALUES('1', '[2, 3]' );
INSERT INTO t1 VALUES('[1, 2]', '3' );
INSERT INTO t1 VALUES('1', '{ "a": 2 }' );
INSERT INTO t1 VALUES('{ "a": 2 }', '1' );
INSERT INTO t1 VALUES('[1, 2]', '[3, 4]' );
INSERT INTO t1 VALUES('{ "a": 2 }', '{ "b": 3}' );
INSERT INTO t1 VALUES('[1, 2]', '{ "a": 2 }' );
INSERT INTO t1 VALUES('{ "a": 2 }', '[1, 2]' );
INSERT INTO t1 VALUES('{"a": 1, "b": 2 }', '{"b": 3, "d": 4 }' );
INSERT INTO t1 VALUES('{"a": 1, "b": 2 }', '{"b": [3, 4], "d": 4 }' );
INSERT INTO t1 VALUES('{"a": 1, "b": [2, 3] }', '{"b": 4, "d": 4 }' );
INSERT INTO t1 VALUES('{"a": 1, "b": 2 }', '{"b": {"e": 7, "f": 8}, "d": 4 }' );
INSERT INTO t1 VALUES('{"b": {"e": 7, "f": 8}, "d": 4 }', '{"a": 1, "b": 2 }' );
INSERT INTO t1 VALUES('{"a": 1, "b": [2, 9] }', '{"b": [10, 11], "d": 4 }' );
INSERT INTO t1 VALUES('{"a": 1, "b": [2, 9] }', '{"b": {"e": 7, "f": 8}, "d": 4 }' );
INSERT INTO t1 VALUES('{"b": {"e": 7, "f": 8}, "d": 4 }', '{"a": 1, "b": [2, 9] }' );
INSERT INTO t1 VALUES('{"b": {"e": 7, "f": 8}, "d": 4 }', '{ "a": 1, "b": {"e": 20, "g": 21 } }' );
INSERT INTO t1 VALUES('{ "a" : "foo", "b" : [ true, { "c" : 123 } ] }', '[ 5, 6]');
INSERT INTO t1 VALUES('{ "a" : "foo", "b" : [ true, { "c" : 123 } ] }', '{ "b": [ false, 34 ] }');
INSERT INTO t1 VALUES('{ "a" : "foo", "b" : [ true, { "c" : 123 } ] }','{ "b": "bar" }');
INSERT INTO t1 VALUES('{ "a" : { "b" : 1 } }','{ "a" : { "c" : 1 } }');
SELECT JSON_MERGE(l, r) FROM t1;
CREATE TABLE t2(l1 TEXT, l2 TEXT, l3 TEXT) ENGINE = columnstore;
INSERT INTO t2 VALUES('1', '2', '3' );
INSERT INTO t2 VALUES('[1, 2 ]', '3', '[4, 5]' );
INSERT INTO t2 VALUES
(
'{ "a": true, "b": { "c": 3, "d": 4 }, "e": [ 1, 2 ] }',
'{ "d": false, "b": { "g": 3, "d": 5 }, "f": [ 1, 2 ] }',
'{ "m": true, "b": { "h": 8, "d": 4 }, "e": [ 3, 4 ] }'
);
SELECT JSON_MERGE(l1, l2, l3) from t2;
DROP TABLE t1;
DROP TABLE t2;
DROP DATABASE json_merge_db;

54
mysql-test/columnstore/basic/t/func_json_merge_patch.test Normal file
View File

@ -0,0 +1,54 @@
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);
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"}');
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"}');
--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,');
SELECT l1, l2, JSON_MERGE_PATCH(l1, l2) AS merged FROM t3;
DROP TABLE t3;
DROP DATABASE json_merge_patch_db;

27
mysql-test/columnstore/basic/t/func_json_normalize.test Normal file
View File

@ -0,0 +1,27 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_normalize_db;
--enable_warnings
CREATE DATABASE json_normalize_db;
USE json_normalize_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_NORMALIZE function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l LONGTEXT) ENGINE = columnstore;
INSERT INTO t1 VALUES('{"key2":"v2","key1":"v1"}');
INSERT INTO t1 VALUES('{"key2": "v2", "key1":"v1"}');
INSERT INTO t1 VALUES('{"key1": "v2", "key1":"v1"}');
INSERT INTO t1 VALUES('{"key1": "v2", "key2":"v1"}');
INSERT INTO t1 VALUES('{}');
INSERT INTO t1 VALUES('{ }');
INSERT INTO t1 VALUES('"123"');
INSERT INTO t1 VALUES('[ 1,2,3]');
INSERT INTO t1 VALUES('[]');
INSERT INTO t1 VALUES('[ ]');
INSERT INTO t1 VALUES(null);
INSERT INTO t1 VALUES('{"key1":value1}');
SELECT JSON_NORMALIZE(l) from t1;
DROP TABLE t1;
DROP DATABASE json_normalize_db;

47
mysql-test/columnstore/basic/t/func_json_object.test Normal file
View File

@ -0,0 +1,47 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_object_db;
--enable_warnings
CREATE DATABASE json_object_db;
USE json_object_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_OBJECT function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l TEXT) ENGINE = COLUMNSTORE;
INSERT INTO t1 VALUES('a');
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT json_object(l) FROM t1;
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT json_object(l, 1, 'b') FROM t1;
--echo # Null arg
TRUNCATE t1;
INSERT INTO t1 values(null);
SELECT JSON_OBJECT(l, 1) FROM t1;
SELECT JSON_OBJECT(1, l) FROM t1;
--echo # Valid arg
TRUNCATE t1;
INSERT INTO t1 values('a');
SELECT JSON_OBJECT(l, null) FROM t1;
SELECT JSON_OBJECT(l, 1) FROM t1;
SELECT JSON_OBJECT(l, 1, 'b', 'foo') FROM t1;
SELECT JSON_OBJECT(l, 1, 'b', 'foo','c','{ "d": "e" }') FROM t1;
SELECT JSON_OBJECT(l, true, 'b', false, 'c', null ) FROM t1;
SELECT JSON_OBJECT(l, 'true', 'b', 'false', 'c', null ) FROM t1;
SELECT JSON_VALID(json_object(l, 1 )) from t1;
--echo # Long key
TRUNCATE t1;
INSERT INTO t1 values('a');
--echo # SELECT JSON_OBJECT(REPEAT(l, 64 * 1024), 1) FROM t1;
--echo # Non-string keys are cast to CHAR
TRUNCATE t1;
INSERT INTO t1 values('a');
SELECT JSON_OBJECT(1, l) FROM t1;
SELECT JSON_OBJECT(CAST(1 AS CHAR), l) FROM t1;
SELECT JSON_OBJECT(true, l) FROM t1;
SELECT JSON_OBJECT(CAST(true AS CHAR), l) FROM t1;
SELECT JSON_OBJECT(false, l) FROM t1;
SELECT JSON_OBJECT(CAST(false AS CHAR), l) FROM t1;
DROP TABLE t1;
DROP DATABASE json_object_db;

182
mysql-test/columnstore/basic/t/func_json_overlaps.test Normal file
View File

@ -0,0 +1,182 @@
--source ../include/disable_before_10.9.inc
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_overlaps_db;
--enable_warnings
CREATE DATABASE json_overlaps_db;
USE json_overlaps_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_OVERLAPS function.
--echo # ----------------------------------------------------------------------
--echo # Comparing scalar
CREATE TABLE t1(l1 LONGTEXT, l2 LONGTEXT) ENGINE = COLUMNSTORE;
INSERT INTO
t1
VALUES
('true', 'true'),
('false', 'false'),
('1', '1'),
('"string1"', '"string1"'),
('null', 'null'),
('true', 'false'),
('1', '"1"'),
('1', '0'),
('null', '0'),
('"string1"', '"string2"'),
('true', '["abc", 1, 2, true, false]'),
('true', '["abc", 1, 2, [true]]'),
('true', '{"A":true}');
SELECT
l1,
l2,
JSON_OVERLAPS(l1, l2) AS is_overlaps
FROM
t1;
--echo # Testing non-scalar json data types
--echo # Comparing object with object (non-nested)
CREATE TABLE t2(l1 LONGTEXT, l2 LONGTEXT) ENGINE = COLUMNSTORE;
INSERT INTO
t2
VALUES
('{"A":[1, 2, 3]}', '{}'),
('{"A": 1}', '{"A": 1}'),
('{"A": 1}', '{"B": 1}'),
(
'{"A": 1, "B": "string1"}',
'{"A": 2,"B": "string1"}'
),
(
'{"A": 1,"B": "string1"}',
'{"A": 2,"B": "string2"}'
),
(
'{"A": 1,"B": {"C":2}}',
'{"A": 2,"B": {"C":1}}'
),
(
'{"A": 1,"B": {"C":2}}',
'{"A": 2,"B": {"C":2}}'
),
(
'{"A": {"B": true}}',
'{"A": {"B": true,"C": false}}'
),
(
'{"A":1, "B":{"D":4, "E":5}}',
'{"C":3, "B":{"E":5, "D":4}}'
),
(
'{"A":1, "B":{"D":4, "E":[5, 6, 7]}}',
'{"C":3, "B":{"E":5, "D":4}}'
),
(
'{"A":1, "B":{"D":4, "E":[5, 6, 7]}}',
'{"C":3, "B":{"E":[5, 6, 7], "D":4}}'
),
(
'{"A":1, "B":{"D":4, "E":[5, 6, 7]}}',
'{"C":3, "B":{"E":[7, 6 ,5], "D":4}}'
),
(
'{"A":1, "B":{"D":4, "E":[5, 6, 7]}}',
'{"C":3, "F":{"E":[5, 6, 7], "D":4}}'
),
('[1, 2, true, false, null]', '[3, 4, 1]'),
('[1, 2, true, false, null]', '[3, 4, 5]'),
('[1,2,3]', '[]'),
('[1, 2, true, false, null]', '[3, 4, [1]]'),
(
'[1, 2, [true, false], null]',
'[[1], [true, false]]'
),
('[1, 2, 3, [4, 5, 6]]', '[7, 8, 9, [6, 5, 4]]'),
('[1, 2, true, false, null]', '{"A": 1}'),
(
'[1, 2, true, false, null, {"A":2}]',
'{"A": 1}'
),
('[1, {"A": 2}, {"A": 1}]', '{"A": 1}'),
(
'[1, 2, true, false, {"A": 1, "B": 2}]',
'{"A": 1, "B": 2}'
),
(
'[1, 2, true, false, {"A": 1, "B": 2}]',
'{"A": 1, "B": 3}'
),
(
'[1, 2, true, false, [{"A": 1, "B": 2}]]',
'{"A": 1, "B": 2}'
),
(
'[1, 2, true, false, [{"A": 1, "B": 2}]]',
'{"A": 1, "B": 3}'
),
(
'[1, 2, true, false, [{"A": 1, "B": 2}]]',
'{"A": 1}'
),
(
'[1, 2, true, false, {"A": 1, "B": {"C": 12}}]',
'{"A": 1, "B": {"C": 12}}'
),
(
'[1, 2, true, false, [{"A": 1, "B": {"C": 12}}]]',
'{"A": 1, "B": {"C": 12}}'
),
(
'[1, 2, true, false, [{"A": 1, "B": {"C": 12}}]]',
'{"A": 1, "B":{"C": 12}}'
),
(
'[[1, 2, true, false, {"A": 1, "B": {"C": 12}}]]',
'{"A": 1, "B": {"C": 12}}'
),
(
'{"A": 1, "B": 3}',
'[1, 2, true, false, {"A": 1, "B": 2}]'
),
(
'{"A": 1, "B": 3}',
'[1, 2, true, false, {"A": 1, "B": 3}]'
),
(
'{"A": 1, "B": 3}',
'[1, 2, true, false, {"A": 1, "B": 2}, {"A": 1, "B": 3}]'
),
(
'{"A": 1, "B": [1, 2, 3]}',
'[1, 2, true, false, {"A": 1, "B": 2}, {"A": 1, "B": [1, 2, 3]}]'
),
(
'{"A": 1, "B": [1, 2, {"C": 3, "D": 5}]}',
'[1, 2, true, false, {"A": 1, "B": 2}, {"A":1, "B":[1, 2, {"C": 3, "D": 5}]}]'
),
(
'{"A": 1, "B": [1, 2, {"C": 3, "D": 5}]}',
'[1, 2, true, false, {"A": 1, "B": 2},{"A": 1, "B": [1, 2, {"C": 3, "D": 4}]}]'
),
(
'{"A": 1, "B": 3}',
'[1, 2, true, false, [{"A": 1, "B": 2}, {"A": 1, "B": 3}]]'
);
SELECT
l1,
l2,
JSON_OVERLAPS(l1, l2) AS is_overlaps
FROM
t2;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_overlaps_db;

181
mysql-test/columnstore/basic/t/func_json_quote.test Normal file
View File

@ -0,0 +1,181 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_quote_db;
--enable_warnings
CREATE DATABASE json_quote_db;
USE json_quote_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_QUOTE, JSON_UNQUOTE function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l LONGTEXT) ENGINE = columnstore;
INSERT INTO
t1
VALUES
(NULL);
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT
JSON_QUOTE(l, NULL)
FROM
t1;
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT
JSON_QUOTE(l, 'bar')
FROM
t1;
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT
JSON_UNQUOTE(l, NULL)
FROM
t1;
--error ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT
SELECT
JSON_UNQUOTE(l, 'bar')
FROM
t1;
--echo # Null arg
SELECT
JSON_QUOTE(l)
FROM
t1;
SELECT
JSON_UNQUOTE(l)
FROM
t1;
--echo # Calling based on encodings
TRUNCATE t1;
INSERT INTO
t1
VALUES
('abc');
SELECT
l AS raw,
JSON_QUOTE(CONVERT(l USING ascii)) AS quote_ascii,
JSON_QUOTE(CONVERT(l USING latin1)) AS quote_latin1,
JSON_QUOTE(CONVERT(l USING utf8)) AS quote_utf8,
JSON_QUOTE(CONVERT(l USING utf8mb4)) AS quote_utf8mb4
FROM
t1;
--echo # Chinese characters (normal in console,abnormal in test)
CREATE TABLE t2(l VARCHAR(50)) ENGINE = columnstore;
INSERT INTO
t2
VALUES
(X'e68891');
SELECT
*
FROM
t2;
SET
NAMES 'utf8';
-- echo # All should be the Chinese "I" i.e. 我
SELECT
JSON_QUOTE(CONVERT(l USING utf8)) AS quote_utf8,
JSON_COMPACT(JSON_QUOTE(CONVERT(l USING utf8))) AS compact_quote_utf8,
JSON_QUOTE(CONVERT(l USING utf8mb4)) AS quote_utf8mb4,
JSON_UNQUOTE(CONVERT(l USING utf8)) AS unquote_utf8
FROM
t2;
--echo # Do nothing
TRUNCATE t1;
INSERT INTO
t1
VALUES
('"');
SELECT
JSON_QUOTE(l),
JSON_UNQUOTE(l)
FROM
t1;
TRUNCATE t1;
INSERT INTO
t1
VALUES
('""');
SELECT
JSON_UNQUOTE(l),
CHAR_LENGTH(JSON_UNQUOTE(l))
FROM
t1;
TRUNCATE t1;
INSERT INTO
t1
VALUES
('"" ');
SELECT
JSON_UNQUOTE(l)
FROM
t1;
--echo # Inconrrect type e.g. Integer
CREATE TABLE t3(i INT) ENGINE = columnstore;
INSERT INTO
t3
VALUES
(123);
SELECT
JSON_QUOTE(i)
FROM
t3;
SELECT
JSON_UNQUOTE(i)
FROM
t3;
--echo # Round trip
TRUNCATE t1;
INSERT INTO
t1
VALUES
('abc');
SELECT
JSON_UNQUOTE(JSON_COMPACT(JSON_QUOTE(l)))
FROM
t1;
SELECT
JSON_UNQUOTE(
JSON_UNQUOTE(
JSON_UNQUOTE(JSON_QUOTE(JSON_QUOTE(JSON_QUOTE(l))))
)
)
FROM
t1;
DROP TABLE t1;
--echo # DROP TABLE t2;
DROP TABLE t3;
DROP DATABASE json_quote_db;

52
mysql-test/columnstore/basic/t/func_json_remove.test Normal file
View File

@ -0,0 +1,52 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_remove_db;
--enable_warnings
CREATE DATABASE json_remove_db;
USE json_remove_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_REMOVE function.
--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]');
SELECT
j AS json,
p AS path,
JSON_REMOVE(j, p) AS result
FROM
t1;
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]');
SELECT
j AS json,
p AS path,
JSON_REMOVE(j, p) AS result
FROM
t2;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_remove_db;

102
mysql-test/columnstore/basic/t/func_json_search.test Normal file
View File

@ -0,0 +1,102 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_search_db;
--enable_warnings
CREATE DATABASE json_search_db;
USE json_search_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_SEARCH function.
--echo # ----------------------------------------------------------------------
--echo
--echo # JSON_SEARCH with single path expression
--echo
CREATE TABLE t1(j TEXT, f TEXT, v TEXT) ENGINE = COLUMNSTORE;
INSERT INTO
t1
VALUES
(
'["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]',
'one',
'abc'
),
(
'["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]',
'all',
'abc'
),
('{"x": "\\""}', "one", '"'),
('{"x": "\\""}', "one", '\\"');
SELECT
j AS json,
f AS return_arg,
v AS search_str,
j AS json, f AS return_arg, JSON_SEARCH(j, f, v) AS result
FROM
t1;
--echo
--echo # JSON_SEARCH with path expression
--echo
CREATE TABLE t2(j TEXT, f TEXT, v TEXT, e TEXT, p TEXT) ENGINE = COLUMNSTORE;
SET
@j = '["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]';
INSERT INTO
t2
VALUES
(@j, 'all', 'abc', NULL, '$[0]'),
(@j, 'all', 'abc', NULL, '$[2]'),
(@j, 'all', '10', NULL, '$[1]'),
(@j, 'all', '10', NULL, '$[2]');
SELECT
j AS json,
f AS return_arg,
v AS search_str,
p AS path,
JSON_SEARCH(j, f, v, NULL, p) AS result
FROM
t2;
--echo
--echo # JSON_SEARCH with escape char
--echo
CREATE TABLE t3(j TEXT, f TEXT) ENGINE = COLUMNSTORE;
set @json = '[ "footbar", "foo%bar" ]';
INSERT INTO t3 VALUES(@json,'all');
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo%bar' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo\%bar' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]', '$[1]' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]', '$[1]', '$[2]' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo\%bar', null ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo\%bar', null, '$[0]' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo\%bar', null, '$[1]' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]' ) FROM t3;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[1]' ) FROM t3;
--echo
--echo # JSON_SEARCH in case-sensitive
--echo
CREATE TABLE t4(j TEXT, f TEXT) ENGINE = COLUMNSTORE;
INSERT INTO t4 VALUES('["abc", "ABC"]', 'all');
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'aBC') FROM t4;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'abc') FROM t4;
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'ABC') FROM t4;
drop TABLE t4;
drop TABLE t3;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_search_db;

51
mysql-test/columnstore/basic/t/func_json_type.test Normal file
View File

@ -0,0 +1,51 @@
--source ../include/disable_before_10.9.inc
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_type_db;
--enable_warnings
CREATE DATABASE json_type_db;
USE json_type_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_TYPE function.
--echo # ----------------------------------------------------------------------
CREATE TABLE t1(l LONGTEXT) ENGINE = COLUMNSTORE;
--echo # Error ER_INVALID_JSON_TEXT_IN_PARAM
INSERT INTO
t1
VALUES
('abc');
SELECT
JSON_TYPE(l)
FROM
t1;
--echo # String literal - valid JSON
TRUNCATE t1;
INSERT INTO
t1
VALUES
('{"a": 2}'),
('[1,2]'),
('"scalar string"'),
('true'),
('false'),
('null'),
('1'),
('-0'),
('-0.0');
SELECT
l AS json,
JSON_TYPE(l) AS TYPE
FROM
t1;
DROP TABLE t1;
DROP DATABASE json_type_db;

195
mysql-test/columnstore/basic/t/func_json_valid.test Normal file
View File

@ -0,0 +1,195 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_valid_db;
--enable_warnings
CREATE DATABASE json_valid_db;
USE json_valid_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_VALID function.
--echo # ----------------------------------------------------------------------
--echo #
--echo # String literal - valid JSON
--echo #
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));
SELECT
l AS raw,
JSON_VALID(l) AS is_valid,
JSON_VALID(JSON_COMPACT(l)) AS compact
FROM
t1;
--echo #
--echo # String literal - invalid JSON
--echo #
TRUNCATE t1;
INSERT INTO
t1
VALUES
('12 3'),
('{key:value}'),
('{key:value'),
('[1,2,]'),
('[1,2');
SELECT
l AS raw,
JSON_VALID(l) AS is_valid,
JSON_VALID(JSON_COMPACT(l)) AS compact
FROM
t1;
--echo #
--echo # String literal - not in UTF-8
--echo #
TRUNCATE t1;
SET
NAMES 'ascii';
INSERT INTO
t1
VALUES
('123');
SELECT
l AS raw,
JSON_VALID(l) AS is_valid,
JSON_VALID(JSON_COMPACT(l)) AS compact
FROM
t1;
SET
NAMES 'utf8';
--echo #
--echo # Bare NULL
--echo #
TRUNCATE t1;
INSERT INTO
t1
VALUES
(NULL);
SELECT
JSON_VALID(l)
FROM
t1;
--echo #
--echo # Function result - string
--echo #
TRUNCATE t1;
INSERT INTO
t1
VALUES
(UPPER('"abc"'));
SELECT
JSON_VALID(l)
FROM
t1;
--echo #
--echo # Function result - string not in UTF-8
--echo #
TRUNCATE t1;
SET
NAMES 'latin1';
INSERT INTO
t1
VALUES
(UPPER('"abc"'));
SELECT
JSON_VALID(l)
FROM
t1;
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));
SELECT
JSON_VALID(l)
FROM
t1;
--echo #
--echo # The date string doesn't parse as JSON text, so wrong:
--echo #
TRUNCATE t1;
INSERT INTO
t1
VALUES
(
CAST(
CAST('2015-01-15' AS DATE) AS CHAR CHARACTER SET 'utf8'
)
);
SELECT
JSON_VALID(l)
FROM
t1;
--echo #
--echo # Function result - NULL
--echo #
TRUNCATE t1;
INSERT INTO
t1
VALUES
(UPPER(NULL));
INSERT INTO
t1
VALUES
(UPPER(CAST(NULL AS CHAR)));
SELECT
JSON_VALID(l)
FROM
t1;
DROP TABLE t1;
DROP DATABASE json_valid_db;

43
mysql-test/columnstore/basic/t/func_json_value.test Normal file
View File

@ -0,0 +1,43 @@
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_value_db;
--enable_warnings
CREATE DATABASE json_value_db;
USE json_value_db;
--echo # ----------------------------------------------------------------------
--echo # Test of JSON_VALUE function.
--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
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]"}');
SELECT s as json_text, '$.key1' , JSON_VALUE(s, '$.key1') as json_value, JSON_QUERY(s, '$.key1') as json_query
FROM t2;
SELECT s as json_text, '$.key2' , JSON_VALUE(s, '$.key2') as json_value, JSON_QUERY(s, '$.key2') as json_query
FROM t2;
SELECT s as json_text, '$.key3' , JSON_VALUE(s, '$.key3') as json_value, JSON_QUERY(s, '$.key3') as json_query
FROM t2;
DROP TABLE t2;
DROP TABLE t1;
DROP DATABASE json_value_db;

153
mysql-test/columnstore/basic/t/json_range_expression.test Normal file
View File

@ -0,0 +1,153 @@
--source ../include/disable_before_10.9.inc
--source ../include/have_columnstore.inc
--disable_warnings
DROP DATABASE IF EXISTS json_range_expr_db;
--enable_warnings
CREATE DATABASE json_range_expr_db;
USE json_range_expr_db;
--echo # Range expression is supported in MariaDB 10.9 binaries
CREATE TABLE t2(j TEXT, p TEXT) ENGINE = columnstore;
SET
@json = '{
"A": [0,
[1, 2, 3],
[4, 5, 6],
"seven",
0.8,
true,
false,
"eleven",
[12, 13, {"key1":"value1"},[15]],
true],
"B": {"C": 1},
"D": 2
}';
INSERT INTO
t2
VALUES
(@json, '$.A[-2][-1]'),
(@json, '$.A[last-1][last]');
SELECT
j,
p,
JSON_EXISTS(j, p) AS result
FROM
t2;
--echo # Test case 2
CREATE TABLE t3(j TEXT, p TEXT) ENGINE = columnstore;
SET
@json = '[
[1, {"key1": "value1"}, 3],
[false, 5, 6],
[7, 8, [9, {"key2": 2}, 11]],
[15, 1.34, [14], ["string1", [16, {"key1":[1,2,3,[4,5,6]]}, 18]]],
[19, 20],
21, 22
]';
INSERT INTO
t3
VALUES
(@json, '$[3][3][-2 to last]');
SELECT
j,
p,
JSON_EXISTS(j, p) AS result
FROM
t3;
-- echo # Test case 3
CREATE TABLE t4(j TEXT, p TEXT) ENGINE = columnstore;
SET
@json = '[
[1, {"key1": "value1"}, 3],
[false, 5, 6],
[7, 8, [9, {"key2": 2}, 11]],
[15, 1.34, [14], ["string1", [16, {"key1":[1,2,3,[4,5,6]]}, 18]]],
[19, 20],
21, 22
]';
INSERT INTO
t4
VALUES
(@json, '$[2][2][1 to 2]'),
(@json, '$[2][2][4 to 6]'),
(@json, '$[2][2][1 to 4]');
SELECT
j,
p,
JSON_EXISTS(j, p) AS result
FROM
t4;
--echo
--echo # JSON_EXTRACT
--echo
CREATE TABLE t5(j LONGTEXT, p LONGTEXT) ENGINE = COLUMNSTORE;
INSERT INTO
t5
VALUES
('[1, "val2", [3.1, -4]]', '$'),
('1', '$'),
('[10, 20, [30, 40]]', '$[2][*]'),
('[10, 20, [{"a":3}, 30, 40]]', '$[2][*]'),
(json_object('foo', 'foobar'), '$');
SELECT
j,
p,
JSON_EXTRACT(j, p) AS result
FROM
t5;
--echo
--echo # JSON_EXTRACT
--echo
CREATE TABLE t6(j TEXT, f TEXT, v TEXT, e TEXT, p TEXT) ENGINE = COLUMNSTORE;
SET
@j = '["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]';
INSERT INTO
t6
VALUES
(@j, 'all', 'abc', NULL, '$'),
(@j, 'all', '10', NULL, '$'),
(@j, 'all', '10', NULL, '$[*]'),
(@j, 'all', '10', NULL, '$[*][0].k'),
(@j, 'all', '10', NULL, '$**.k');
SELECT
j AS json,
f AS return_arg,
v AS search_str,
e AS escape_char,
p AS path,
JSON_SEARCH(j, f, v, NULL, p) AS result
FROM
t6;
DROP TABLE t6;
DROP TABLE t5;
DROP TABLE t4;
DROP TABLE t3;
DROP TABLE t2;
DROP DATABASE json_range_expr_db;