You've already forked mariadb-columnstore-engine
mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-07-30 19:23:07 +03:00
MCOL-785 Implement DISTRIBUTED JSON functions
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
28
mysql-test/columnstore/basic/r/func_json_array.result
Normal file
28
mysql-test/columnstore/basic/r/func_json_array.result
Normal file
@ -0,0 +1,28 @@
|
||||
DROP DATABASE IF EXISTS json_array_db;
|
||||
CREATE DATABASE json_array_db;
|
||||
USE json_array_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_ARRAY function.
|
||||
# ----------------------------------------------------------------------
|
||||
CREATE TABLE t1(l text) ENGINE = COLUMNSTORE;
|
||||
INSERT INTO t1 VALUES('1');
|
||||
SELECT JSON_ARRAY() FROM t1;
|
||||
JSON_ARRAY()
|
||||
[]
|
||||
SELECT JSON_ARRAY(l) FROM t1;
|
||||
JSON_ARRAY(l)
|
||||
["1"]
|
||||
SELECT JSON_ARRAY(l, null, 'My name is "Foo"', 3.1415, 6) FROM t1;
|
||||
JSON_ARRAY(l, null, 'My name is "Foo"', 3.1415, 6)
|
||||
["1", null, "My name is \"Foo\"", 3.1415, 6]
|
||||
SELECT JSON_ARRAY(l, true, false, "true", "false") FROM t1;
|
||||
JSON_ARRAY(l, true, false, "true", "false")
|
||||
["1", true, false, "true", "false"]
|
||||
SELECT JSON_ARRAY(l, '{"key1":"value1"}') FROM t1;
|
||||
JSON_ARRAY(l, '{"key1":"value1"}')
|
||||
["1", "{\"key1\":\"value1\"}"]
|
||||
SELECT JSON_ARRAY(l, JSON_COMPACT( '{"key1":"value1"}' ) ) FROM t1;
|
||||
JSON_ARRAY(l, JSON_COMPACT( '{"key1":"value1"}' ) )
|
||||
["1", "{\"key1\":\"value1\"}"]
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_array_db;
|
||||
94
mysql-test/columnstore/basic/r/func_json_array_append.result
Normal file
94
mysql-test/columnstore/basic/r/func_json_array_append.result
Normal file
@ -0,0 +1,94 @@
|
||||
DROP DATABASE IF EXISTS json_array_append_db;
|
||||
CREATE DATABASE json_array_append_db;
|
||||
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'
|
||||
);
|
||||
SELECT
|
||||
a AS arrary,
|
||||
p AS path,
|
||||
v AS value,
|
||||
JSON_ARRAY_APPEND(a, p, v) AS result
|
||||
FROM
|
||||
t1;
|
||||
arrary path value result
|
||||
[1,2,3] $[0] 2 [[1, "2"], 2, 3]
|
||||
[1,2,3] $[0] 1.2 [[1, "1.2"], 2, 3]
|
||||
[1,2,3] $[0] key1 [[1, "key1"], 2, 3]
|
||||
[1,2,3] $[0] 1 [[1, "1"], 2, 3]
|
||||
[1,2,3] $[0] 0 [[1, "0"], 2, 3]
|
||||
[1,2,3] $[0] NULL [[1, null], 2, 3]
|
||||
{"a": "foo", "b": "bar", "c": "wibble" } $.b 4 {"a": "foo", "b": ["bar", "4"], "c": "wibble"}
|
||||
{"a": "foo", "b": "bar", "c": "wibble" } $.c grape {"a": "foo", "b": "bar", "c": ["wibble", "grape"]}
|
||||
{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]} $.b 4 {"a": "foo", "b": [1, 2, 3, "4"], "c": ["apple", "pear"]}
|
||||
{"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]');
|
||||
SELECT
|
||||
JSON_ARRAY_APPEND(a, NULL, JSON_COMPACT(1)),
|
||||
JSON_ARRAY_APPEND(a, '$', NULL)
|
||||
FROM
|
||||
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');
|
||||
SELECT
|
||||
JSON_ARRAY_APPEND(NULL, a, JSON_COMPACT(1)),
|
||||
JSON_ARRAY_APPEND('[1,2,3]', a, NULL)
|
||||
FROM
|
||||
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]');
|
||||
error ER_INVALID_JSON_PATH_WILDCARD
|
||||
SELECT
|
||||
JSON_ARRAY_APPEND(JSON_COMPACT('{"a": {"b": [3]}}'), a, 6)
|
||||
FROM
|
||||
t2;
|
||||
JSON_ARRAY_APPEND(JSON_COMPACT('{"a": {"b": [3]}}'), a, 6)
|
||||
NULL
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_array_append_db;
|
||||
94
mysql-test/columnstore/basic/r/func_json_array_insert.result
Normal file
94
mysql-test/columnstore/basic/r/func_json_array_insert.result
Normal file
@ -0,0 +1,94 @@
|
||||
DROP DATABASE IF EXISTS json_array_insert_db;
|
||||
CREATE DATABASE json_array_insert_db;
|
||||
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'
|
||||
);
|
||||
SELECT
|
||||
a AS arrary,
|
||||
p AS path,
|
||||
v AS value,
|
||||
JSON_ARRAY_INSERT(a, p, v) AS result
|
||||
FROM
|
||||
t1;
|
||||
arrary path value result
|
||||
[1,2,3] $[0] 2 ["2", 1, 2, 3]
|
||||
[1,2,3] $[0] 1.2 ["1.2", 1, 2, 3]
|
||||
[1,2,3] $[0] key1 ["key1", 1, 2, 3]
|
||||
[1,2,3] $[0] 1 ["1", 1, 2, 3]
|
||||
[1,2,3] $[0] 0 ["0", 1, 2, 3]
|
||||
[1,2,3] $[0] NULL [null, 1, 2, 3]
|
||||
{"a": "foo", "b": "bar", "c": "wibble" } $.b 4 NULL
|
||||
{"a": "foo", "b": "bar", "c": "wibble" } $.c grape NULL
|
||||
{"a": "foo", "b": [1,2,3], "c": ["apple","pear"]} $.b 4 NULL
|
||||
{"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]');
|
||||
SELECT
|
||||
JSON_ARRAY_INSERT(a, NULL, JSON_COMPACT(1)),
|
||||
JSON_ARRAY_INSERT(a, '$', NULL)
|
||||
FROM
|
||||
t2;
|
||||
JSON_ARRAY_INSERT(a, NULL, JSON_COMPACT(1)) JSON_ARRAY_INSERT(a, '$', NULL)
|
||||
NULL NULL
|
||||
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;
|
||||
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]');
|
||||
error ER_INVALID_JSON_PATH_WILDCARD
|
||||
SELECT
|
||||
JSON_ARRAY_INSERT(JSON_COMPACT('{"a": {"b": [3]}}'), a, 6)
|
||||
FROM
|
||||
t2;
|
||||
JSON_ARRAY_INSERT(JSON_COMPACT('{"a": {"b": [3]}}'), a, 6)
|
||||
NULL
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_array_insert_db;
|
||||
81
mysql-test/columnstore/basic/r/func_json_contains.result
Normal file
81
mysql-test/columnstore/basic/r/func_json_contains.result
Normal file
@ -0,0 +1,81 @@
|
||||
DROP DATABASE IF EXISTS json_contains_db;
|
||||
CREATE DATABASE json_contains_db;
|
||||
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', '$');
|
||||
SELECT
|
||||
j AS json,
|
||||
v AS value,
|
||||
p AS path,
|
||||
JSON_CONTAINS(j, v, p) AS result
|
||||
FROM
|
||||
t1;
|
||||
json value path result
|
||||
{"k1":123, "k2":345} 123 $.k1 1
|
||||
NULL NULL $ NULL
|
||||
null null $ 1
|
||||
"10" "10" $ 1
|
||||
"10" 10 $ 0
|
||||
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"}');
|
||||
SELECT
|
||||
j AS json,
|
||||
v AS value,
|
||||
JSON_CONTAINS(j, v) AS result
|
||||
FROM
|
||||
t2;
|
||||
json value result
|
||||
"you" "you" 1
|
||||
"youth" "you" 0
|
||||
[1] 1 1
|
||||
[2, 1] 1 1
|
||||
[2, [2, 3], 1] 1 1
|
||||
[4, [2, 3], 1] 2 1
|
||||
[2, 1] [1, 2] 1
|
||||
[2, 1] [1, 0, 2] 0
|
||||
[2, 0, 3, 1] [1, 2] 1
|
||||
{"b":[1,2], "a":1} {"a":1, "b":2} 1
|
||||
{"a":1} {} 1
|
||||
[1, {"a":1}] {} 1
|
||||
[1, {"a":1}] {"a":1} 1
|
||||
[{"abc":"def", "def":"abc"}] ["foo","bar"] 0
|
||||
[{"abc":"def", "def":"abc"}, "bar"] ["bar", {}] 1
|
||||
[{"a":"b"},{"c":"d"}] {"c":"d"} 1
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_contains_db;
|
||||
@ -0,0 +1,69 @@
|
||||
DROP DATABASE IF EXISTS json_contains_path_db;
|
||||
CREATE DATABASE json_contains_path_db;
|
||||
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.*');
|
||||
SELECT
|
||||
j AS json,
|
||||
r AS return_flag,
|
||||
p AS path,
|
||||
JSON_CONTAINS_PATH(j, r, p) AS result
|
||||
FROM
|
||||
t1;
|
||||
json return_flag path result
|
||||
{"key1":1, "key2":[2,3]} oNE $.key2[1] 1
|
||||
{"key1":1, "key2":[2,3]} oNE $.key2[10] 0
|
||||
{"key1":1, "key2":[2,3]} oNE $.ma 0
|
||||
{"key1":1, "key2":[2,3]} one $.key1 1
|
||||
{ "a": true } NULL $.a NULL
|
||||
{ "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"
|
||||
);
|
||||
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;
|
||||
json return_flag path path result
|
||||
{"key1":1, "key2":[2,3]} one $.key1 $.ma 1
|
||||
{"key1":1, "key2":[2,3]} aLl $.key1 $.ma 0
|
||||
{"key1":1, "key2":[2,3]} aLl $.key1 $.key2 1
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_contains_path_db;
|
||||
57
mysql-test/columnstore/basic/r/func_json_depth.result
Normal file
57
mysql-test/columnstore/basic/r/func_json_depth.result
Normal file
@ -0,0 +1,57 @@
|
||||
DROP DATABASE IF EXISTS json_depth_db;
|
||||
CREATE DATABASE json_depth_db;
|
||||
USE json_depth_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_DEPTH function.
|
||||
# ----------------------------------------------------------------------
|
||||
CREATE TABLE t1(l LONGTEXT) ENGINE = columnstore;
|
||||
# Return NULL
|
||||
INSERT INTO t1 VALUES(NULL);
|
||||
SELECT JSON_DEPTH(l) FROM t1;
|
||||
JSON_DEPTH(l)
|
||||
NULL
|
||||
# Return 1
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('{}');
|
||||
INSERT INTO t1 VALUES('[]');
|
||||
INSERT INTO t1 VALUES('"abc"');
|
||||
SELECT JSON_DEPTH(l) FROM t1;
|
||||
JSON_DEPTH(l)
|
||||
1
|
||||
1
|
||||
1
|
||||
# Error ER_INVALID_TYPE_FOR_JSON
|
||||
CREATE TABLE t2(i int) ENGINE=columnstore;
|
||||
INSERT INTO t2 VALUES(1);
|
||||
SELECT JSON_DEPTH(i) FROM t2;
|
||||
JSON_DEPTH(i)
|
||||
1
|
||||
DROP TABLE t2;
|
||||
# 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;
|
||||
JSON_DEPTH(l)
|
||||
NULL
|
||||
NULL
|
||||
# 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;
|
||||
JSON_DEPTH(l)
|
||||
2
|
||||
2
|
||||
2
|
||||
2
|
||||
# Return 3
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('{ "a" : true, "b" : { "e" : false }, "c" : null }');
|
||||
SELECT JSON_DEPTH(l) FROM t1;
|
||||
JSON_DEPTH(l)
|
||||
3
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_depth_db;
|
||||
44
mysql-test/columnstore/basic/r/func_json_equals.result
Normal file
44
mysql-test/columnstore/basic/r/func_json_equals.result
Normal file
@ -0,0 +1,44 @@
|
||||
DROP DATABASE IF EXISTS json_equals_db;
|
||||
CREATE DATABASE json_equals_db;
|
||||
USE json_equals_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_EQUALS function.
|
||||
# ----------------------------------------------------------------------
|
||||
# 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;
|
||||
JSON_EQUALS(l, r)
|
||||
1
|
||||
1
|
||||
1
|
||||
1
|
||||
1
|
||||
1
|
||||
1
|
||||
# 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;
|
||||
JSON_EQUALS(l, r)
|
||||
0
|
||||
0
|
||||
0
|
||||
# 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;
|
||||
JSON_EQUALS(l, r)
|
||||
NULL
|
||||
NULL
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_equals_db;
|
||||
32
mysql-test/columnstore/basic/r/func_json_exists.result
Normal file
32
mysql-test/columnstore/basic/r/func_json_exists.result
Normal file
@ -0,0 +1,32 @@
|
||||
DROP DATABASE IF EXISTS json_exists_db;
|
||||
CREATE DATABASE json_exists_db;
|
||||
USE json_exists_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_EXISTS function.
|
||||
# ----------------------------------------------------------------------
|
||||
# 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;
|
||||
j p result
|
||||
{"key1":"xxxx", "key2":[1, 2, 3]} $.key1 1
|
||||
{"key1":"xxxx", "key2":[1, 2, 3]} $.key1[0] 1
|
||||
{"key1":"xxxx", "key2":[1, 2, 3]} $.key2 1
|
||||
{"key1":"xxxx", "key2":[1, 2, 3]} $.key2[1] 1
|
||||
{"key1":"xxxx", "key2":[1, 2, 3]} $.key2[10] 0
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_exists_db;
|
||||
88
mysql-test/columnstore/basic/r/func_json_extract.result
Normal file
88
mysql-test/columnstore/basic/r/func_json_extract.result
Normal file
@ -0,0 +1,88 @@
|
||||
DROP DATABASE IF EXISTS json_extract_db;
|
||||
CREATE DATABASE json_extract_db;
|
||||
USE json_extract_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_EXTRACT function.
|
||||
# ----------------------------------------------------------------------
|
||||
|
||||
# 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'), '$');
|
||||
SELECT
|
||||
j,
|
||||
p,
|
||||
JSON_EXTRACT(j, p) AS result
|
||||
FROM
|
||||
t1;
|
||||
j p result
|
||||
[1, "val2", [3.1, -4]] $[0] 1
|
||||
[1, "val2", [3.1, -4]] $[1] "val2"
|
||||
[1, "val2", [3.1, -4]] $[2] [3.1, -4]
|
||||
[1, "val2", [3.1, -4]] $[3] NULL
|
||||
[1, "val2", [3.1, -4]] $[2][0] 3.1
|
||||
[1, "val2", [3.1, -4]] $[2][1] -4
|
||||
[1, "val2", [3.1, -4]] $[2][10] NULL
|
||||
[1, "val2", [3.1, -4]] $ [1, "val2", [3.1, -4]]
|
||||
1 $ 1
|
||||
[10, 20, [30, 40], 1, 10] $[1] 20
|
||||
{"key1":"asd", "key2":[2,3]} $.key1 "asd"
|
||||
{"key0":true, "key1":"qwe"} $.key1 "qwe"
|
||||
[10, 20, [30, 40]] $[2][*] [30, 40]
|
||||
[10, 20, [{"a":3}, 30, 40]] $[2][*] [{"a": 3}, 30, 40]
|
||||
{"foo": "foobar"} $ {"foo": "foobar"}
|
||||
|
||||
# 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');
|
||||
SELECT
|
||||
j,
|
||||
p1,
|
||||
p2,
|
||||
JSON_EXTRACT(j, p1, p2) AS result
|
||||
FROM
|
||||
t2;
|
||||
j p1 p2 result
|
||||
{"key1":"asd", "key2":[2,3]} $.keyX $.keyY NULL
|
||||
{"key1":"asd", "key2":[2,3]} $.key1 $.key2 ["asd", [2, 3]]
|
||||
{"key1":5, "key2":[2,3]} $.key1 $.key2 [5, [2, 3]]
|
||||
[10, 20, [30, 40], 1, 10] $[1] $[25] [20]
|
||||
[{"a": [3, 4]}, {"b": 2}] $[0].a $[1].a [[3, 4]]
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_extract_db;
|
||||
56
mysql-test/columnstore/basic/r/func_json_insert.result
Normal file
56
mysql-test/columnstore/basic/r/func_json_insert.result
Normal file
@ -0,0 +1,56 @@
|
||||
DROP DATABASE IF EXISTS json_insert_de;
|
||||
CREATE DATABASE json_insert_de;
|
||||
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]'
|
||||
);
|
||||
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;
|
||||
json path value json_insert json_replace json_set
|
||||
{"a":1, "b":{"c":1}, "d":[1, 2]} $.b.k1 word {"a": 1, "b": {"c": 1, "k1": "word"}, "d": [1, 2]} {"a": 1, "b": {"c": 1}, "d": [1, 2]} {"a": 1, "b": {"c": 1, "k1": "word"}, "d": [1, 2]}
|
||||
{"a":1, "b":{"c":1}, "d":[1, 2]} $.d[3] 3 {"a": 1, "b": {"c": 1}, "d": [1, 2, "3"]} {"a": 1, "b": {"c": 1}, "d": [1, 2]} {"a": 1, "b": {"c": 1}, "d": [1, 2, "3"]}
|
||||
{"a":1, "b":{"c":1}, "d":[1, 2]} $.a[2] 2 {"a": [1, "2"], "b": {"c": 1}, "d": [1, 2]} {"a": 1, "b": {"c": 1}, "d": [1, 2]} {"a": [1, "2"], "b": {"c": 1}, "d": [1, 2]}
|
||||
{"a":1, "b":{"c":1}, "d":[1, 2]} $.b.c word {"a": 1, "b": {"c": 1}, "d": [1, 2]} {"a": 1, "b": {"c": "word"}, "d": [1, 2]} {"a": 1, "b": {"c": "word"}, "d": [1, 2]}
|
||||
1 $[0] 4 1 NULL NULL
|
||||
[] $[0][0] 100 [] [] []
|
||||
1 $[0][0] 100 1 NULL NULL
|
||||
{ "a": 1, "b": [2, 3]} $.a 10 {"a": 1, "b": [2, 3]} {"a": "10", "b": [2, 3]} {"a": "10", "b": [2, 3]}
|
||||
{ "a": 1, "b": [2, 3]} $.b [true, false] {"a": 1, "b": [2, 3]} {"a": 1, "b": "[true, false]"} {"a": 1, "b": "[true, false]"}
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_insert_de;
|
||||
32
mysql-test/columnstore/basic/r/func_json_keys.result
Normal file
32
mysql-test/columnstore/basic/r/func_json_keys.result
Normal file
@ -0,0 +1,32 @@
|
||||
DROP DATABASE IF EXISTS json_keys_db;
|
||||
CREATE DATABASE json_keys_db;
|
||||
USE json_keys_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_KEYS function.
|
||||
# ----------------------------------------------------------------------
|
||||
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;
|
||||
JSON_KEYS(l)
|
||||
["key1", "key2"]
|
||||
["key1", "key2"]
|
||||
NULL
|
||||
SELECT JSON_KEYS(l, '$.key2') from t1;
|
||||
JSON_KEYS(l, '$.key2')
|
||||
["key3"]
|
||||
["key3", "key4"]
|
||||
NULL
|
||||
SELECT JSON_KEYS(l, '$.key1') from t1;
|
||||
JSON_KEYS(l, '$.key1')
|
||||
NULL
|
||||
NULL
|
||||
NULL
|
||||
SELECT JSON_KEYS(l, '$.key123') from t1;
|
||||
JSON_KEYS(l, '$.key123')
|
||||
NULL
|
||||
NULL
|
||||
NULL
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_keys_db;
|
||||
123
mysql-test/columnstore/basic/r/func_json_length.result
Normal file
123
mysql-test/columnstore/basic/r/func_json_length.result
Normal file
@ -0,0 +1,123 @@
|
||||
DROP DATABASE IF EXISTS json_length_db;
|
||||
CREATE DATABASE json_length_db;
|
||||
USE json_length_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_LENGTH function.
|
||||
# ----------------------------------------------------------------------
|
||||
CREATE TABLE t1(l LONGTEXT) ENGINE = columnstore;
|
||||
# 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');
|
||||
error ER_INVALID_JSON_TEXT_IN_PARAM
|
||||
SELECT JSON_LENGTH(l) FROM t1;
|
||||
JSON_LENGTH(l)
|
||||
NULL
|
||||
1
|
||||
NULL
|
||||
1
|
||||
1
|
||||
1
|
||||
1
|
||||
# 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;
|
||||
JSON_LENGTH(l)
|
||||
0
|
||||
2
|
||||
2
|
||||
0
|
||||
4
|
||||
4
|
||||
1
|
||||
1
|
||||
# Bad path expressions
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('true');
|
||||
error ER_INVALID_JSON_PATH
|
||||
SELECT JSON_LENGTH(l, 'c$') FROM t1;
|
||||
JSON_LENGTH(l, 'c$')
|
||||
NULL
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('{ "foo" : [ true, false ] }');
|
||||
error ER_INVALID_JSON_PATH
|
||||
SELECT JSON_LENGTH(l, '$.foo[bar]') FROM t1;
|
||||
JSON_LENGTH(l, '$.foo[bar]')
|
||||
NULL
|
||||
# wildcards not allowed in path expressions for this function
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('true');
|
||||
error ER_INVALID_JSON_PATH_WILDCARD
|
||||
SELECT JSON_LENGTH(l, '$.*') FROM t1;
|
||||
JSON_LENGTH(l, '$.*')
|
||||
NULL
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('true');
|
||||
error ER_INVALID_JSON_PATH_WILDCARD
|
||||
SELECT JSON_LENGTH(l, '$.foo**.bar') FROM t1;
|
||||
JSON_LENGTH(l, '$.foo**.bar')
|
||||
NULL
|
||||
# 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;
|
||||
JSON_LENGTH(l)
|
||||
NULL
|
||||
NULL
|
||||
# Path exist
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('[ 1, [ 2, 3, 4 ], 5 ]');
|
||||
SELECT JSON_LENGTH(l, '$[0]') FROM t1;
|
||||
JSON_LENGTH(l, '$[0]')
|
||||
1
|
||||
SELECT JSON_LENGTH(l, '$[1]') FROM t1;
|
||||
JSON_LENGTH(l, '$[1]')
|
||||
3
|
||||
SELECT JSON_LENGTH(l, '$[2]') FROM t1;
|
||||
JSON_LENGTH(l, '$[2]')
|
||||
1
|
||||
SELECT JSON_LENGTH(l, '$[2][0]') FROM t1;
|
||||
JSON_LENGTH(l, '$[2][0]')
|
||||
1
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('[ 1, [ 2, 3, 4 ], {"a": 1} ]');
|
||||
SELECT JSON_LENGTH(l, '$[2][0]') FROM t1;
|
||||
JSON_LENGTH(l, '$[2][0]')
|
||||
1
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('[ 1, { "a": true, "b": false, "c": null }, 5 ]');
|
||||
SELECT JSON_LENGTH(l, '$[1]') FROM t1;
|
||||
JSON_LENGTH(l, '$[1]')
|
||||
3
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('{ "a" : 123, "b" : [ 123, 456, 789 ] }');
|
||||
SELECT JSON_LENGTH(l) FROM t1;
|
||||
JSON_LENGTH(l)
|
||||
2
|
||||
SELECT JSON_LENGTH(l, '$.b') FROM t1;
|
||||
JSON_LENGTH(l, '$.b')
|
||||
3
|
||||
SELECT JSON_LENGTH(l, '$.c') FROM t1;
|
||||
JSON_LENGTH(l, '$.c')
|
||||
NULL
|
||||
# No-existent path
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 VALUES('[ 1, [ 2, 3, 4 ], 5 ]');
|
||||
SELECT JSON_LENGTH(l, '$[2][1]') FROM t1;
|
||||
JSON_LENGTH(l, '$[2][1]')
|
||||
NULL
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_length_db;
|
||||
105
mysql-test/columnstore/basic/r/func_json_merge.result
Normal file
105
mysql-test/columnstore/basic/r/func_json_merge.result
Normal file
@ -0,0 +1,105 @@
|
||||
DROP DATABASE IF EXISTS json_merge_db;
|
||||
CREATE DATABASE json_merge_db;
|
||||
USE json_merge_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_MERGE function.
|
||||
# ----------------------------------------------------------------------
|
||||
CREATE TABLE t1(l TEXT, r TEXT) ENGINE = columnstore;
|
||||
INSERT INTO t1 VALUES('[1, 2, 3]','[4, 5, 6]');
|
||||
# Not enough args
|
||||
SELECT JSON_MERGE() FROM t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'JSON_MERGE'
|
||||
SELECT JSON_MERGE(l) FROM t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'JSON_MERGE'
|
||||
SELECT JSON_MERGE(NULL) FROM t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'JSON_MERGE'
|
||||
# Null args
|
||||
SELECT JSON_MERGE(NULL, r) FROM t1;
|
||||
JSON_MERGE(NULL, r)
|
||||
NULL
|
||||
SELECT JSON_MERGE(l, NULL) FROM t1;
|
||||
JSON_MERGE(l, NULL)
|
||||
NULL
|
||||
SELECT JSON_MERGE(NULL, l, r) FROM t1;
|
||||
JSON_MERGE(NULL, l, r)
|
||||
NULL
|
||||
SELECT JSON_MERGE(l, NULL, r) FROM t1;
|
||||
JSON_MERGE(l, NULL, r)
|
||||
NULL
|
||||
SELECT JSON_MERGE(l, r, NULL) FROM t1;
|
||||
JSON_MERGE(l, r, NULL)
|
||||
NULL
|
||||
# Invalid JSON text
|
||||
error ER_INVALID_JSON_TEXT_IN_PARAM
|
||||
SELECT JSON_MERGE(l, '[4, 5, 6') FROM t1;
|
||||
JSON_MERGE(l, '[4, 5, 6')
|
||||
NULL
|
||||
error ER_INVALID_JSON_TEXT_IN_PARAM
|
||||
SELECT JSON_MERGE('[1, 2, 3', r) FROM t1;
|
||||
JSON_MERGE('[1, 2, 3', r)
|
||||
NULL
|
||||
# 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;
|
||||
JSON_MERGE(l, r)
|
||||
[1, 2]
|
||||
[1, 2, 3]
|
||||
[1, 2, 3]
|
||||
[1, {"a": 2}]
|
||||
[{"a": 2}, 1]
|
||||
[1, 2, 3, 4]
|
||||
{"a": 2, "b": 3}
|
||||
[1, 2, {"a": 2}]
|
||||
[{"a": 2}, 1, 2]
|
||||
{"a": 1, "b": [2, 3], "d": 4}
|
||||
{"a": 1, "b": [2, 3, 4], "d": 4}
|
||||
{"a": 1, "b": [2, 3, 4], "d": 4}
|
||||
{"a": 1, "b": [2, {"e": 7, "f": 8}], "d": 4}
|
||||
{"b": [{"e": 7, "f": 8}, 2], "d": 4, "a": 1}
|
||||
{"a": 1, "b": [2, 9, 10, 11], "d": 4}
|
||||
{"a": 1, "b": [2, 9, {"e": 7, "f": 8}], "d": 4}
|
||||
{"b": [{"e": 7, "f": 8}, 2, 9], "d": 4, "a": 1}
|
||||
{"b": {"e": [7, 20], "f": 8, "g": 21}, "d": 4, "a": 1}
|
||||
[{"a": "foo", "b": [true, {"c": 123}]}, 5, 6]
|
||||
{"a": "foo", "b": [true, {"c": 123}, false, 34]}
|
||||
{"a": "foo", "b": [true, {"c": 123}, "bar"]}
|
||||
{"a": {"b": 1, "c": 1}}
|
||||
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;
|
||||
JSON_MERGE(l1, l2, l3)
|
||||
[1, 2, 3]
|
||||
[1, 2, 3, 4, 5]
|
||||
{"a": true, "b": {"c": 3, "d": [4, 5, 4], "g": 3, "h": 8}, "e": [1, 2, 3, 4], "d": false, "f": [1, 2], "m": true}
|
||||
DROP TABLE t1;
|
||||
DROP TABLE t2;
|
||||
DROP DATABASE json_merge_db;
|
||||
77
mysql-test/columnstore/basic/r/func_json_merge_patch.result
Normal file
77
mysql-test/columnstore/basic/r/func_json_merge_patch.result
Normal file
@ -0,0 +1,77 @@
|
||||
DROP DATABASE IF EXISTS json_merge_patch_db;
|
||||
Warnings:
|
||||
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);
|
||||
SELECT l1, l2,
|
||||
JSON_MERGE_PATCH(l1, l2) AS `l1 + l2`
|
||||
FROM t1;
|
||||
l1 l2 l1 + l2
|
||||
{"a":"b"} {"a":"c"} {"a": "c"}
|
||||
{"a":"b"} {"b":"c"} {"a": "b", "b": "c"}
|
||||
{"a":"b"} {"a":null} {}
|
||||
{"a":"b", "b":"c"} {"a":null} {"b": "c"}
|
||||
{"a":["b"]} {"a":"c"} {"a": "c"}
|
||||
{"a":"c"} {"a":["b"]} {"a": ["b"]}
|
||||
{"a": {"b":"c"}} {"a": {"b":"d", "c":null}} {"a": {"b": "d"}}
|
||||
{"a":[{"b":"c"}]} {"a": [1]} {"a": [1]}
|
||||
["a","b"] ["c","d"] ["c", "d"]
|
||||
{"a":"b"} ["c"] ["c"]
|
||||
{"a":"foo"} null null
|
||||
{"a":"foo"} "bar" "bar"
|
||||
{"e":null} {"a":1} {"e": null, "a": 1}
|
||||
[1,2] {"a":"b", "c":null} {"a": "b"}
|
||||
{} {"a":{"bb":{"ccc":null}}} {"a": {"bb": {}}}
|
||||
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"}');
|
||||
SELECT l1, l2, l3,
|
||||
JSON_MERGE_PATCH(l1, l2, l3) AS merged
|
||||
FROM t2;
|
||||
l1 l2 l3 merged
|
||||
{"a":"b"} NULL {"c":"d"} NULL
|
||||
NULL [1,2,3] [4,5,6] [4, 5, 6]
|
||||
NULL a b NULL
|
||||
{"a":"b"} [1,2,3] {"c":null,"d":"e"} {"d": "e"}
|
||||
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"}');
|
||||
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,');
|
||||
SELECT l1, l2, JSON_MERGE_PATCH(l1, l2) AS merged FROM t3;
|
||||
l1 l2 merged
|
||||
{} {"a":"c"} {"a": "c"}
|
||||
{ [1,2,3] NULL
|
||||
{"a":"b"} [1, NULL
|
||||
DROP TABLE t3;
|
||||
DROP DATABASE json_merge_patch_db;
|
||||
35
mysql-test/columnstore/basic/r/func_json_normalize.result
Normal file
35
mysql-test/columnstore/basic/r/func_json_normalize.result
Normal file
@ -0,0 +1,35 @@
|
||||
DROP DATABASE IF EXISTS json_normalize_db;
|
||||
CREATE DATABASE json_normalize_db;
|
||||
USE json_normalize_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_NORMALIZE function.
|
||||
# ----------------------------------------------------------------------
|
||||
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;
|
||||
JSON_NORMALIZE(l)
|
||||
{"key1":"v1","key2":"v2"}
|
||||
{"key1":"v1","key2":"v2"}
|
||||
{"key1":"v2","key1":"v1"}
|
||||
{"key1":"v2","key2":"v1"}
|
||||
{}
|
||||
{}
|
||||
"123"
|
||||
[1.0E0,2.0E0,3.0E0]
|
||||
[]
|
||||
[]
|
||||
NULL
|
||||
NULL
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_normalize_db;
|
||||
72
mysql-test/columnstore/basic/r/func_json_object.result
Normal file
72
mysql-test/columnstore/basic/r/func_json_object.result
Normal file
@ -0,0 +1,72 @@
|
||||
DROP DATABASE IF EXISTS json_object_db;
|
||||
CREATE DATABASE json_object_db;
|
||||
USE json_object_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_OBJECT function.
|
||||
# ----------------------------------------------------------------------
|
||||
CREATE TABLE t1(l TEXT) ENGINE = COLUMNSTORE;
|
||||
INSERT INTO t1 VALUES('a');
|
||||
SELECT json_object(l) FROM t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'json_object'
|
||||
SELECT json_object(l, 1, 'b') FROM t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'json_object'
|
||||
# Null arg
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 values(null);
|
||||
SELECT JSON_OBJECT(l, 1) FROM t1;
|
||||
JSON_OBJECT(l, 1)
|
||||
{"": 1}
|
||||
SELECT JSON_OBJECT(1, l) FROM t1;
|
||||
JSON_OBJECT(1, l)
|
||||
{"1": null}
|
||||
# Valid arg
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 values('a');
|
||||
SELECT JSON_OBJECT(l, null) FROM t1;
|
||||
JSON_OBJECT(l, null)
|
||||
{"a": null}
|
||||
SELECT JSON_OBJECT(l, 1) FROM t1;
|
||||
JSON_OBJECT(l, 1)
|
||||
{"a": 1}
|
||||
SELECT JSON_OBJECT(l, 1, 'b', 'foo') FROM t1;
|
||||
JSON_OBJECT(l, 1, 'b', 'foo')
|
||||
{"a": 1, "b": "foo"}
|
||||
SELECT JSON_OBJECT(l, 1, 'b', 'foo','c','{ "d": "e" }') FROM t1;
|
||||
JSON_OBJECT(l, 1, 'b', 'foo','c','{ "d": "e" }')
|
||||
{"a": 1, "b": "foo", "c": "{ \"d\": \"e\" }"}
|
||||
SELECT JSON_OBJECT(l, true, 'b', false, 'c', null ) FROM t1;
|
||||
JSON_OBJECT(l, true, 'b', false, 'c', null )
|
||||
{"a": true, "b": false, "c": null}
|
||||
SELECT JSON_OBJECT(l, 'true', 'b', 'false', 'c', null ) FROM t1;
|
||||
JSON_OBJECT(l, 'true', 'b', 'false', 'c', null )
|
||||
{"a": "true", "b": "false", "c": null}
|
||||
SELECT JSON_VALID(json_object(l, 1 )) from t1;
|
||||
JSON_VALID(json_object(l, 1 ))
|
||||
1
|
||||
# Long key
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 values('a');
|
||||
# SELECT JSON_OBJECT(REPEAT(l, 64 * 1024), 1) FROM t1;
|
||||
# Non-string keys are cast to CHAR
|
||||
TRUNCATE t1;
|
||||
INSERT INTO t1 values('a');
|
||||
SELECT JSON_OBJECT(1, l) FROM t1;
|
||||
JSON_OBJECT(1, l)
|
||||
{"1": "a"}
|
||||
SELECT JSON_OBJECT(CAST(1 AS CHAR), l) FROM t1;
|
||||
JSON_OBJECT(CAST(1 AS CHAR), l)
|
||||
{"1": "a"}
|
||||
SELECT JSON_OBJECT(true, l) FROM t1;
|
||||
JSON_OBJECT(true, l)
|
||||
{"1": "a"}
|
||||
SELECT JSON_OBJECT(CAST(true AS CHAR), l) FROM t1;
|
||||
JSON_OBJECT(CAST(true AS CHAR), l)
|
||||
{"1": "a"}
|
||||
SELECT JSON_OBJECT(false, l) FROM t1;
|
||||
JSON_OBJECT(false, l)
|
||||
{"0": "a"}
|
||||
SELECT JSON_OBJECT(CAST(false AS CHAR), l) FROM t1;
|
||||
JSON_OBJECT(CAST(false AS CHAR), l)
|
||||
{"0": "a"}
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_object_db;
|
||||
220
mysql-test/columnstore/basic/r/func_json_overlaps.result
Normal file
220
mysql-test/columnstore/basic/r/func_json_overlaps.result
Normal file
@ -0,0 +1,220 @@
|
||||
DROP DATABASE IF EXISTS json_overlaps_db;
|
||||
CREATE DATABASE json_overlaps_db;
|
||||
USE json_overlaps_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_OVERLAPS function.
|
||||
# ----------------------------------------------------------------------
|
||||
# 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;
|
||||
l1 l2 is_overlaps
|
||||
true true 1
|
||||
false false 1
|
||||
1 1 1
|
||||
"string1" "string1" 1
|
||||
null null 1
|
||||
true false 0
|
||||
1 "1" 0
|
||||
1 0 0
|
||||
null 0 0
|
||||
"string1" "string2" 0
|
||||
true ["abc", 1, 2, true, false] 1
|
||||
true ["abc", 1, 2, [true]] 0
|
||||
true {"A":true} 0
|
||||
# Testing non-scalar json data types
|
||||
# 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;
|
||||
l1 l2 is_overlaps
|
||||
{"A":[1, 2, 3]} {} 0
|
||||
{"A": 1} {"A": 1} 1
|
||||
{"A": 1} {"B": 1} 0
|
||||
{"A": 1, "B": "string1"} {"A": 2,"B": "string1"} 1
|
||||
{"A": 1,"B": "string1"} {"A": 2,"B": "string2"} 0
|
||||
{"A": 1,"B": {"C":2}} {"A": 2,"B": {"C":1}} 0
|
||||
{"A": 1,"B": {"C":2}} {"A": 2,"B": {"C":2}} 1
|
||||
{"A": {"B": true}} {"A": {"B": true,"C": false}} 0
|
||||
{"A":1, "B":{"D":4, "E":5}} {"C":3, "B":{"E":5, "D":4}} 1
|
||||
{"A":1, "B":{"D":4, "E":[5, 6, 7]}} {"C":3, "B":{"E":5, "D":4}} 0
|
||||
{"A":1, "B":{"D":4, "E":[5, 6, 7]}} {"C":3, "B":{"E":[5, 6, 7], "D":4}} 1
|
||||
{"A":1, "B":{"D":4, "E":[5, 6, 7]}} {"C":3, "B":{"E":[7, 6 ,5], "D":4}} 0
|
||||
{"A":1, "B":{"D":4, "E":[5, 6, 7]}} {"C":3, "F":{"E":[5, 6, 7], "D":4}} 0
|
||||
[1, 2, true, false, null] [3, 4, 1] 1
|
||||
[1, 2, true, false, null] [3, 4, 5] 0
|
||||
[1,2,3] [] 0
|
||||
[1, 2, true, false, null] [3, 4, [1]] 0
|
||||
[1, 2, [true, false], null] [[1], [true, false]] 1
|
||||
[1, 2, 3, [4, 5, 6]] [7, 8, 9, [6, 5, 4]] 0
|
||||
[1, 2, true, false, null] {"A": 1} 0
|
||||
[1, 2, true, false, null, {"A":2}] {"A": 1} 0
|
||||
[1, {"A": 2}, {"A": 1}] {"A": 1} 1
|
||||
[1, 2, true, false, {"A": 1, "B": 2}] {"A": 1, "B": 2} 1
|
||||
[1, 2, true, false, {"A": 1, "B": 2}] {"A": 1, "B": 3} 0
|
||||
[1, 2, true, false, [{"A": 1, "B": 2}]] {"A": 1, "B": 2} 0
|
||||
[1, 2, true, false, [{"A": 1, "B": 2}]] {"A": 1, "B": 3} 0
|
||||
[1, 2, true, false, [{"A": 1, "B": 2}]] {"A": 1} 0
|
||||
[1, 2, true, false, {"A": 1, "B": {"C": 12}}] {"A": 1, "B": {"C": 12}} 1
|
||||
[1, 2, true, false, [{"A": 1, "B": {"C": 12}}]] {"A": 1, "B": {"C": 12}} 0
|
||||
[1, 2, true, false, [{"A": 1, "B": {"C": 12}}]] {"A": 1, "B":{"C": 12}} 0
|
||||
[[1, 2, true, false, {"A": 1, "B": {"C": 12}}]] {"A": 1, "B": {"C": 12}} 0
|
||||
{"A": 1, "B": 3} [1, 2, true, false, {"A": 1, "B": 2}] 0
|
||||
{"A": 1, "B": 3} [1, 2, true, false, {"A": 1, "B": 3}] 1
|
||||
{"A": 1, "B": 3} [1, 2, true, false, {"A": 1, "B": 2}, {"A": 1, "B": 3}] 1
|
||||
{"A": 1, "B": [1, 2, 3]} [1, 2, true, false, {"A": 1, "B": 2}, {"A": 1, "B": [1, 2, 3]}] 1
|
||||
{"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}]}] 1
|
||||
{"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}]}] 0
|
||||
{"A": 1, "B": 3} [1, 2, true, false, [{"A": 1, "B": 2}, {"A": 1, "B": 3}]] 0
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_overlaps_db;
|
||||
168
mysql-test/columnstore/basic/r/func_json_quote.result
Normal file
168
mysql-test/columnstore/basic/r/func_json_quote.result
Normal file
@ -0,0 +1,168 @@
|
||||
DROP DATABASE IF EXISTS json_quote_db;
|
||||
CREATE DATABASE json_quote_db;
|
||||
USE json_quote_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_QUOTE, JSON_UNQUOTE function.
|
||||
# ----------------------------------------------------------------------
|
||||
CREATE TABLE t1(l LONGTEXT) ENGINE = columnstore;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
(NULL);
|
||||
SELECT
|
||||
JSON_QUOTE(l, NULL)
|
||||
FROM
|
||||
t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'JSON_QUOTE'
|
||||
SELECT
|
||||
JSON_QUOTE(l, 'bar')
|
||||
FROM
|
||||
t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'JSON_QUOTE'
|
||||
SELECT
|
||||
JSON_UNQUOTE(l, NULL)
|
||||
FROM
|
||||
t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'JSON_UNQUOTE'
|
||||
SELECT
|
||||
JSON_UNQUOTE(l, 'bar')
|
||||
FROM
|
||||
t1;
|
||||
ERROR 42000: Incorrect parameter count in the call to native function 'JSON_UNQUOTE'
|
||||
# Null arg
|
||||
SELECT
|
||||
JSON_QUOTE(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_QUOTE(l)
|
||||
NULL
|
||||
SELECT
|
||||
JSON_UNQUOTE(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_UNQUOTE(l)
|
||||
NULL
|
||||
# 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;
|
||||
raw quote_ascii quote_latin1 quote_utf8 quote_utf8mb4
|
||||
abc "abc" "abc" "abc" "abc"
|
||||
# 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;
|
||||
l
|
||||
我
|
||||
SET
|
||||
NAMES 'utf8';
|
||||
# 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;
|
||||
quote_utf8 compact_quote_utf8 quote_utf8mb4 unquote_utf8
|
||||
"我" "我" "我" 我
|
||||
# Do nothing
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
('"');
|
||||
SELECT
|
||||
JSON_QUOTE(l),
|
||||
JSON_UNQUOTE(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_QUOTE(l) JSON_UNQUOTE(l)
|
||||
"\"" "
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
('""');
|
||||
SELECT
|
||||
JSON_UNQUOTE(l),
|
||||
CHAR_LENGTH(JSON_UNQUOTE(l))
|
||||
FROM
|
||||
t1;
|
||||
JSON_UNQUOTE(l) CHAR_LENGTH(JSON_UNQUOTE(l))
|
||||
NULL 0
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
('"" ');
|
||||
SELECT
|
||||
JSON_UNQUOTE(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_UNQUOTE(l)
|
||||
NULL
|
||||
# Inconrrect type e.g. Integer
|
||||
CREATE TABLE t3(i INT) ENGINE = columnstore;
|
||||
INSERT INTO
|
||||
t3
|
||||
VALUES
|
||||
(123);
|
||||
SELECT
|
||||
JSON_QUOTE(i)
|
||||
FROM
|
||||
t3;
|
||||
JSON_QUOTE(i)
|
||||
NULL
|
||||
SELECT
|
||||
JSON_UNQUOTE(i)
|
||||
FROM
|
||||
t3;
|
||||
JSON_UNQUOTE(i)
|
||||
123
|
||||
# Round trip
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
('abc');
|
||||
SELECT
|
||||
JSON_UNQUOTE(JSON_COMPACT(JSON_QUOTE(l)))
|
||||
FROM
|
||||
t1;
|
||||
JSON_UNQUOTE(JSON_COMPACT(JSON_QUOTE(l)))
|
||||
abc
|
||||
SELECT
|
||||
JSON_UNQUOTE(
|
||||
JSON_UNQUOTE(
|
||||
JSON_UNQUOTE(JSON_QUOTE(JSON_QUOTE(JSON_QUOTE(l))))
|
||||
)
|
||||
)
|
||||
FROM
|
||||
t1;
|
||||
JSON_UNQUOTE(
|
||||
JSON_UNQUOTE(
|
||||
JSON_UNQUOTE(JSON_QUOTE(JSON_QUOTE(JSON_QUOTE(l))))
|
||||
)
|
||||
)
|
||||
abc
|
||||
DROP TABLE t1;
|
||||
# DROP TABLE t2;
|
||||
DROP TABLE t3;
|
||||
DROP DATABASE json_quote_db;
|
||||
49
mysql-test/columnstore/basic/r/func_json_remove.result
Normal file
49
mysql-test/columnstore/basic/r/func_json_remove.result
Normal file
@ -0,0 +1,49 @@
|
||||
DROP DATABASE IF EXISTS json_remove_db;
|
||||
CREATE DATABASE json_remove_db;
|
||||
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]');
|
||||
SELECT
|
||||
j AS json,
|
||||
p AS path,
|
||||
JSON_REMOVE(j, p) AS result
|
||||
FROM
|
||||
t1;
|
||||
json path result
|
||||
["a", ["b", "c"], "d"] $[0] [["b", "c"], "d"]
|
||||
["a", ["b", "c"], "d"] $[1] ["a", "d"]
|
||||
["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]');
|
||||
SELECT
|
||||
j AS json,
|
||||
p AS path,
|
||||
JSON_REMOVE(j, p) AS result
|
||||
FROM
|
||||
t2;
|
||||
json path result
|
||||
{"a": 1, "b": [2, 3]} $.a {"b": [2, 3]}
|
||||
{"a": 1, "b": [2, 3]} $.a[0] {"a": 1, "b": [2, 3]}
|
||||
{"a": 1, "b": [2, 3]} $.b {"a": 1}
|
||||
{"a": 1, "b": [2, 3]} $.b[0] {"a": 1, "b": [3]}
|
||||
{"a": 1, "b": [2, 3]} $.b[1] {"a": 1, "b": [2]}
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_remove_db;
|
||||
121
mysql-test/columnstore/basic/r/func_json_search.result
Normal file
121
mysql-test/columnstore/basic/r/func_json_search.result
Normal file
@ -0,0 +1,121 @@
|
||||
DROP DATABASE IF EXISTS json_search_db;
|
||||
CREATE DATABASE json_search_db;
|
||||
USE json_search_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_SEARCH function.
|
||||
# ----------------------------------------------------------------------
|
||||
|
||||
# JSON_SEARCH with single path expression
|
||||
|
||||
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;
|
||||
json return_arg search_str json return_arg result
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] one abc ["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] one "$[0]"
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all abc ["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all ["$[0]", "$[2].x"]
|
||||
{"x": "\""} one " {"x": "\""} one "$.x"
|
||||
{"x": "\""} one \" {"x": "\""} one "$.x"
|
||||
|
||||
# JSON_SEARCH with path expression
|
||||
|
||||
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;
|
||||
json return_arg search_str path result
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all abc $[0] "$[0]"
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all abc $[2] "$[2].x"
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all 10 $[1] "$[1][0].k"
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all 10 $[2] NULL
|
||||
|
||||
# JSON_SEARCH with escape char
|
||||
|
||||
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;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo%bar' )
|
||||
[ "footbar", "foo%bar" ] all ["$[0]", "$[1]"]
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo\%bar' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo\%bar' )
|
||||
[ "footbar", "foo%bar" ] all "$[1]"
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo|%bar', '|' )
|
||||
[ "footbar", "foo%bar" ] all "$[1]"
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]' )
|
||||
[ "footbar", "foo%bar" ] all NULL
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]', '$[1]' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]', '$[1]' )
|
||||
[ "footbar", "foo%bar" ] all "$[1]"
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]', '$[1]', '$[2]' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]', '$[1]', '$[2]' )
|
||||
[ "footbar", "foo%bar" ] all "$[1]"
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo\%bar', null ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo\%bar', null )
|
||||
[ "footbar", "foo%bar" ] all "$[1]"
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo\%bar', null, '$[0]' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo\%bar', null, '$[0]' )
|
||||
[ "footbar", "foo%bar" ] all NULL
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo\%bar', null, '$[1]' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo\%bar', null, '$[1]' )
|
||||
[ "footbar", "foo%bar" ] all "$[1]"
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo|%bar', '|', '$[0]' )
|
||||
[ "footbar", "foo%bar" ] all NULL
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'foo|%bar', '|', '$[1]' ) FROM t3;
|
||||
json return_arg JSON_SEARCH(j, f, 'foo|%bar', '|', '$[1]' )
|
||||
[ "footbar", "foo%bar" ] all "$[1]"
|
||||
|
||||
# JSON_SEARCH in case-sensitive
|
||||
|
||||
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;
|
||||
json return_arg JSON_SEARCH(j, f, 'aBC')
|
||||
["abc", "ABC"] all ["$[0]", "$[1]"]
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'abc') FROM t4;
|
||||
json return_arg JSON_SEARCH(j, f, 'abc')
|
||||
["abc", "ABC"] all ["$[0]", "$[1]"]
|
||||
SELECT j AS json, f AS return_arg, JSON_SEARCH(j, f, 'ABC') FROM t4;
|
||||
json return_arg JSON_SEARCH(j, f, 'ABC')
|
||||
["abc", "ABC"] all ["$[0]", "$[1]"]
|
||||
drop TABLE t4;
|
||||
drop TABLE t3;
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_search_db;
|
||||
49
mysql-test/columnstore/basic/r/func_json_type.result
Normal file
49
mysql-test/columnstore/basic/r/func_json_type.result
Normal file
@ -0,0 +1,49 @@
|
||||
DROP DATABASE IF EXISTS json_type_db;
|
||||
CREATE DATABASE json_type_db;
|
||||
USE json_type_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_TYPE function.
|
||||
# ----------------------------------------------------------------------
|
||||
CREATE TABLE t1(l LONGTEXT) ENGINE = COLUMNSTORE;
|
||||
# Error ER_INVALID_JSON_TEXT_IN_PARAM
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
('abc');
|
||||
SELECT
|
||||
JSON_TYPE(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_TYPE(l)
|
||||
NULL
|
||||
# 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;
|
||||
json TYPE
|
||||
{"a": 2} OBJECT
|
||||
[1,2] ARRAY
|
||||
"scalar string" STRING
|
||||
true BOOLEAN
|
||||
false BOOLEAN
|
||||
null NULL
|
||||
1 INTEGER
|
||||
-0 INTEGER
|
||||
-0.0 DOUBLE
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_type_db;
|
||||
191
mysql-test/columnstore/basic/r/func_json_valid.result
Normal file
191
mysql-test/columnstore/basic/r/func_json_valid.result
Normal file
@ -0,0 +1,191 @@
|
||||
DROP DATABASE IF EXISTS json_valid_db;
|
||||
CREATE DATABASE json_valid_db;
|
||||
USE json_valid_db;
|
||||
# ----------------------------------------------------------------------
|
||||
# Test of JSON_VALID function.
|
||||
# ----------------------------------------------------------------------
|
||||
#
|
||||
# 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));
|
||||
SELECT
|
||||
l AS raw,
|
||||
JSON_VALID(l) AS is_valid,
|
||||
JSON_VALID(JSON_COMPACT(l)) AS compact
|
||||
FROM
|
||||
t1;
|
||||
raw is_valid compact
|
||||
123 1 1
|
||||
-123 1 1
|
||||
5000000000 1 1
|
||||
-5000000000 1 1
|
||||
1.23 1 1
|
||||
"123" 1 1
|
||||
true 1 1
|
||||
false 1 1
|
||||
null 1 1
|
||||
{"address": "Trondheim"} 1 1
|
||||
{} 1 1
|
||||
{"1": 2} 1 1
|
||||
[] 1 1
|
||||
[1, 2] 1 1
|
||||
#
|
||||
# String literal - invalid JSON
|
||||
#
|
||||
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;
|
||||
raw is_valid compact
|
||||
12 3 0 NULL
|
||||
{key:value} 0 NULL
|
||||
{key:value 0 NULL
|
||||
[1,2,] 0 NULL
|
||||
[1,2 0 NULL
|
||||
#
|
||||
# String literal - not in UTF-8
|
||||
#
|
||||
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;
|
||||
raw is_valid compact
|
||||
123 1 1
|
||||
SET
|
||||
NAMES 'utf8';
|
||||
#
|
||||
# Bare NULL
|
||||
#
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
(NULL);
|
||||
SELECT
|
||||
JSON_VALID(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_VALID(l)
|
||||
NULL
|
||||
#
|
||||
# Function result - string
|
||||
#
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
(UPPER('"abc"'));
|
||||
SELECT
|
||||
JSON_VALID(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_VALID(l)
|
||||
1
|
||||
#
|
||||
# Function result - string not in UTF-8
|
||||
#
|
||||
TRUNCATE t1;
|
||||
SET
|
||||
NAMES 'latin1';
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
(UPPER('"abc"'));
|
||||
SELECT
|
||||
JSON_VALID(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_VALID(l)
|
||||
1
|
||||
SET
|
||||
NAMES 'utf8';
|
||||
#
|
||||
# Function result - date, not valid as JSON without CAST
|
||||
#
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
(CAST('2015-01-15' AS DATE));
|
||||
SELECT
|
||||
JSON_VALID(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_VALID(l)
|
||||
0
|
||||
#
|
||||
# The date string doesn't parse as JSON text, so wrong:
|
||||
#
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
(
|
||||
CAST(
|
||||
CAST('2015-01-15' AS DATE) AS CHAR CHARACTER SET 'utf8'
|
||||
)
|
||||
);
|
||||
SELECT
|
||||
JSON_VALID(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_VALID(l)
|
||||
0
|
||||
#
|
||||
# Function result - NULL
|
||||
#
|
||||
TRUNCATE t1;
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
(UPPER(NULL));
|
||||
INSERT INTO
|
||||
t1
|
||||
VALUES
|
||||
(UPPER(CAST(NULL AS CHAR)));
|
||||
SELECT
|
||||
JSON_VALID(l)
|
||||
FROM
|
||||
t1;
|
||||
JSON_VALID(l)
|
||||
NULL
|
||||
NULL
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_valid_db;
|
||||
51
mysql-test/columnstore/basic/r/func_json_value.result
Normal file
51
mysql-test/columnstore/basic/r/func_json_value.result
Normal file
@ -0,0 +1,51 @@
|
||||
DROP DATABASE IF EXISTS json_value_db;
|
||||
CREATE DATABASE json_value_db;
|
||||
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
|
||||
FROM t1;
|
||||
json_text path json_value json_query
|
||||
{"key1":123} $.key2 NULL NULL
|
||||
{"key1":123} $.key1 123 NULL
|
||||
{"key1":[1,2,3]} $.key1 NULL [1,2,3]
|
||||
{"key1": [1,2,3], "key1":123} $.key1 123 [1,2,3]
|
||||
{ "x": [0,1], "y": "[0,1]", "z": "Mon\"t\"y" } $.z Mon"t"y NULL
|
||||
{"\"key1":123} $."\"key1" 123 NULL
|
||||
{"\"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]"}');
|
||||
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
|
||||
{"key1":123, "key2":{"key3":"value3"}} $.key1 123 NULL
|
||||
{"key1":123, "key3":[1,2,3]} $.key1 123 NULL
|
||||
{"key1":123, "key2":"[1]"} $.key1 123 NULL
|
||||
SELECT s as json_text, '$.key2' , JSON_VALUE(s, '$.key2') as json_value, JSON_QUERY(s, '$.key2') as json_query
|
||||
FROM t2;
|
||||
json_text $.key2 json_value json_query
|
||||
{"key1":123, "key2":{"key3":"value3"}} $.key2 NULL {"key3":"value3"}
|
||||
{"key1":123, "key3":[1,2,3]} $.key2 NULL NULL
|
||||
{"key1":123, "key2":"[1]"} $.key2 [1] NULL
|
||||
SELECT s as json_text, '$.key3' , JSON_VALUE(s, '$.key3') as json_value, JSON_QUERY(s, '$.key3') as json_query
|
||||
FROM t2;
|
||||
json_text $.key3 json_value json_query
|
||||
{"key1":123, "key2":{"key3":"value3"}} $.key3 NULL NULL
|
||||
{"key1":123, "key3":[1,2,3]} $.key3 NULL [1,2,3]
|
||||
{"key1":123, "key2":"[1]"} $.key3 NULL NULL
|
||||
DROP TABLE t2;
|
||||
DROP TABLE t1;
|
||||
DROP DATABASE json_value_db;
|
||||
197
mysql-test/columnstore/basic/r/json_range_expression.result
Normal file
197
mysql-test/columnstore/basic/r/json_range_expression.result
Normal file
@ -0,0 +1,197 @@
|
||||
DROP DATABASE IF EXISTS json_range_expr_db;
|
||||
CREATE DATABASE json_range_expr_db;
|
||||
USE json_range_expr_db;
|
||||
# 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;
|
||||
j p result
|
||||
{
|
||||
"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
|
||||
} $.A[-2][-1] 1
|
||||
{
|
||||
"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
|
||||
} $.A[last-1][last] 1
|
||||
# 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;
|
||||
j p result
|
||||
[
|
||||
[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
|
||||
] $[3][3][-2 to last] 1
|
||||
# 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;
|
||||
j p result
|
||||
[
|
||||
[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
|
||||
] $[2][2][1 to 2] 1
|
||||
[
|
||||
[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
|
||||
] $[2][2][4 to 6] 0
|
||||
[
|
||||
[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
|
||||
] $[2][2][1 to 4] 1
|
||||
|
||||
# JSON_EXTRACT
|
||||
|
||||
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;
|
||||
j p result
|
||||
[1, "val2", [3.1, -4]] $ [1, "val2", [3.1, -4]]
|
||||
1 $ 1
|
||||
[10, 20, [30, 40]] $[2][*] [30, 40]
|
||||
[10, 20, [{"a":3}, 30, 40]] $[2][*] [{"a": 3}, 30, 40]
|
||||
{"foo": "foobar"} $ {"foo": "foobar"}
|
||||
|
||||
# JSON_EXTRACT
|
||||
|
||||
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;
|
||||
json return_arg search_str escape_char path result
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all abc NULL $ ["$[0]", "$[2].x"]
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all 10 NULL $ "$[1][0].k"
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all 10 NULL $[*] "$[1][0].k"
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all 10 NULL $[*][0].k "$[1][0].k"
|
||||
["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}] all 10 NULL $**.k "$[1][0].k"
|
||||
DROP TABLE t6;
|
||||
DROP TABLE t5;
|
||||
DROP TABLE t4;
|
||||
DROP TABLE t3;
|
||||
DROP TABLE t2;
|
||||
DROP DATABASE json_range_expr_db;
|
||||
21
mysql-test/columnstore/basic/t/func_json_array.test
Normal file
21
mysql-test/columnstore/basic/t/func_json_array.test
Normal 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
97
mysql-test/columnstore/basic/t/func_json_array_append.test
Normal 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
97
mysql-test/columnstore/basic/t/func_json_array_insert.test
Normal 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
70
mysql-test/columnstore/basic/t/func_json_contains.test
Normal 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
71
mysql-test/columnstore/basic/t/func_json_contains_path.test
Normal 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
45
mysql-test/columnstore/basic/t/func_json_depth.test
Normal 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
34
mysql-test/columnstore/basic/t/func_json_equals.test
Normal 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
37
mysql-test/columnstore/basic/t/func_json_exists.test
Normal 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
81
mysql-test/columnstore/basic/t/func_json_extract.test
Normal 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
56
mysql-test/columnstore/basic/t/func_json_insert.test
Normal 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
21
mysql-test/columnstore/basic/t/func_json_keys.test
Normal 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
81
mysql-test/columnstore/basic/t/func_json_length.test
Normal 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
79
mysql-test/columnstore/basic/t/func_json_merge.test
Normal 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
54
mysql-test/columnstore/basic/t/func_json_merge_patch.test
Normal 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
27
mysql-test/columnstore/basic/t/func_json_normalize.test
Normal 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
47
mysql-test/columnstore/basic/t/func_json_object.test
Normal 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
182
mysql-test/columnstore/basic/t/func_json_overlaps.test
Normal 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
181
mysql-test/columnstore/basic/t/func_json_quote.test
Normal 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
52
mysql-test/columnstore/basic/t/func_json_remove.test
Normal 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
102
mysql-test/columnstore/basic/t/func_json_search.test
Normal 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
51
mysql-test/columnstore/basic/t/func_json_type.test
Normal 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
195
mysql-test/columnstore/basic/t/func_json_valid.test
Normal 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
43
mysql-test/columnstore/basic/t/func_json_value.test
Normal 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
153
mysql-test/columnstore/basic/t/json_range_expression.test
Normal 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;
|
||||
4
mysql-test/columnstore/include/disable_before_10.9.inc
Normal file
4
mysql-test/columnstore/include/disable_before_10.9.inc
Normal file
@ -0,0 +1,4 @@
|
||||
if (`select version() not like '%10.9%'`)
|
||||
{
|
||||
skip Should run with after MariaDB 10.9 binaries;
|
||||
}
|
||||
Reference in New Issue
Block a user