Hướng dẫn mysql json_contains in where clause - mysql json_contains trong mệnh đề where

Ví dụ: tôi có một cột có tên JSON trong Bảng A

Cột JSON chứa dữ liệu JSON như thế này:

record 1 : {"dept_code": "012", "unit_code": "22"}
record 2 : {"dept_code": "013", "unit_code": "23"}
etc

Tôi muốn lấy các bản ghi dữ liệu với cột JSON có chứa dept_code = 012

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Làm thế nào tôi có thể làm điều đó?

Ghi chú :

Tôi đã cố gắng tìm câu trả lời trên trang web StackOverflow, nhưng tôi không tìm thấy nó. Vì vậy, tôi đặt câu hỏi này

Đã hỏi ngày 29 tháng 12 năm 2016 lúc 23:27Dec 29, 2016 at 23:27

Moses tohmoses tohmoses toh

11.4K63 Huy hiệu vàng224 Huy hiệu bạc404 Huy hiệu đồng63 gold badges224 silver badges404 bronze badges

Có lẽ điều này có thể giúp:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

Đã trả lời ngày 29 tháng 12 năm 2016 lúc 23:37Dec 29, 2016 at 23:37

Khá chắc chắn

select * from table_A
where json_contains[json, '012', '$.dept_code']

8 là những gì bạn muốn. Xem các tài liệu ở đây

Tôi không có hộp cát để kiểm tra điều này ngay bây giờ, nhưng ví dụ của bạn sẽ chuyển thành một cái gì đó như:

select * from table_A
where json_contains[json, '012', '$.dept_code']

Vì Dept_code là một thuộc tính của đối tượng được lưu trữ trong cột JSON.

Đã trả lời ngày 29 tháng 12 năm 2016 lúc 23:49Dec 29, 2016 at 23:49

SLIMSGHOSTSLIMSGHOSTSlimsGhost

2.7891 Huy hiệu vàng9 Huy hiệu bạc15 Huy hiệu đồng1 gold badge9 silver badges15 bronze badges

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

Đã trả lời ngày 29 tháng 12 năm 2016 lúc 23:33Dec 29, 2016 at 23:33

MihaimihaiMihai

25.4K7 Huy hiệu vàng65 Huy hiệu bạc79 Huy hiệu đồng7 gold badges65 silver badges79 bronze badges

Các chức năng trong phần này thực hiện các hoạt động tìm kiếm hoặc so sánh trên các giá trị JSON để trích xuất dữ liệu từ chúng, báo cáo xem dữ liệu có tồn tại tại một vị trí trong chúng hay báo cáo đường dẫn đến dữ liệu trong chúng hay không. Toán tử

select * from table_A
where json_contains[json, '012', '$.dept_code']

9 cũng được ghi lại trong tài liệu này.

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

0, ________ 41 [,

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2]]

Cho biết bằng cách trả về 1 hoặc 0 cho dù tài liệu JSON

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

1 đã cho được chứa trong tài liệu JSON

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

4 hay nếu một đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 được cung cấp cho dù ứng cử viên được tìm thấy tại một đường dẫn cụ thể trong mục tiêu. Trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6 Nếu bất kỳ đối số nào là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6 hoặc nếu đối số đường dẫn không xác định một phần của tài liệu đích. Lỗi xảy ra nếu

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

4 hoặc

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

1 không phải là tài liệu JSON hợp lệ hoặc nếu đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 không phải là biểu thức đường dẫn hợp lệ hoặc chứa ký tự đại diện

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

1 hoặc

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

Để chỉ kiểm tra xem có bất kỳ dữ liệu nào tồn tại trên đường dẫn hay không, hãy sử dụng

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

3 thay thế.

Các quy tắc sau xác định ngăn chặn:

Một vô hướng ứng cử viên được chứa trong một vô hướng mục tiêu khi và chỉ khi chúng có thể so sánh và bằng nhau. Hai giá trị vô hướng có thể so sánh nếu chúng có cùng loại

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

4, ngoại trừ các giá trị của các loại

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

5 và

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

6 cũng có thể so sánh với nhau.

Một mảng ứng cử viên được chứa trong một mảng đích khi và chỉ khi mọi yếu tố trong ứng cử viên được chứa trong một số yếu tố của mục tiêu.
Một ứng cử viên không có trong một mảng mục tiêu khi và chỉ khi ứng viên được chứa trong một số yếu tố của mục tiêu.
Một đối tượng ứng cử viên được chứa trong một đối tượng đích khi và chỉ khi đối với mỗi khóa trong ứng viên, có một khóa có cùng tên trong mục tiêu và giá trị được liên kết với khóa ứng viên được chứa trong giá trị liên quan đến khóa đích.

Mặt khác, giá trị ứng cử viên không có trong tài liệu đích.

Bắt đầu với MySQL 8.0.17, các truy vấn sử dụng

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

7 trên bảng

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

8 có thể được tối ưu hóa bằng các chỉ mục đa giá trị; Xem các chỉ mục đa giá trị, để biết thêm thông tin.

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

0, ________ 42 [,

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2] ...]

Trả về 0 hoặc 1 để cho biết liệu tài liệu JSON có chứa dữ liệu tại một đường dẫn hoặc đường dẫn nhất định hay không. Trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6 nếu có bất kỳ đối số là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6. Xảy ra lỗi nếu đối số

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

5 không phải là tài liệu JSON hợp lệ, bất kỳ đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 nào không phải là biểu thức đường dẫn hợp lệ hoặc

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

0 không phải là

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

8 hoặc

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

Để kiểm tra một giá trị cụ thể tại một đường dẫn, hãy sử dụng

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

7 thay thế.

Giá trị trả về là 0 nếu không có đường dẫn được chỉ định tồn tại trong tài liệu. Mặt khác, giá trị trả về phụ thuộc vào đối số

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

8: 1 Nếu ít nhất một đường dẫn tồn tại trong tài liệu, 0 nếu không.

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

9: 1 Nếu tất cả các đường dẫn tồn tại trong tài liệu, 0 nếu không.

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

JSON_EXTRACT [________ 65, ________ 42 [,

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2] ...]

Trả về dữ liệu từ một tài liệu JSON, được chọn từ các phần của tài liệu được khớp với các đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2. Trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6 Nếu bất kỳ đối số nào là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6 hoặc không có đường dẫn định vị một giá trị trong tài liệu. Xảy ra lỗi nếu đối số

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

5 không phải là tài liệu JSON hợp lệ hoặc bất kỳ đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 nào không phải là biểu thức đường dẫn hợp lệ.

Giá trị trả về bao gồm tất cả các giá trị phù hợp với các đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2. Nếu có thể các đối số đó có thể trả về nhiều giá trị, các giá trị phù hợp được tự động tạo thành một mảng, theo thứ tự tương ứng với các đường dẫn tạo ra chúng. Mặt khác, giá trị trả về là giá trị phù hợp duy nhất.

mysql> SELECT JSON_EXTRACT['[10, 20, [30, 40]]', '$[1]'];
+--------------------------------------------+
| JSON_EXTRACT['[10, 20, [30, 40]]', '$[1]'] |
+--------------------------------------------+
| 20                                         |
+--------------------------------------------+
mysql> SELECT JSON_EXTRACT['[10, 20, [30, 40]]', '$[1]', '$[0]'];
+----------------------------------------------------+
| JSON_EXTRACT['[10, 20, [30, 40]]', '$[1]', '$[0]'] |
+----------------------------------------------------+
| [20, 10]                                           |
+----------------------------------------------------+
mysql> SELECT JSON_EXTRACT['[10, 20, [30, 40]]', '$[2][*]'];
+-----------------------------------------------+
| JSON_EXTRACT['[10, 20, [30, 40]]', '$[2][*]'] |
+-----------------------------------------------+
| [30, 40]                                      |
+-----------------------------------------------+

MySQL hỗ trợ toán tử

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

3 làm cách viết tắt cho chức năng này như được sử dụng với 2 đối số trong đó phía bên trái là định danh cột

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

4 [không phải biểu thức] và phía bên phải là đường dẫn JSON được khớp trong cột.

________ 85-> ________ 42

Toán tử

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

3 đóng vai trò là bí danh cho hàm

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

8 khi được sử dụng với hai đối số, một định danh cột ở bên trái và đường dẫn JSON [một chuỗi chữ] ở bên phải được đánh giá theo tài liệu JSON [giá trị cột]. Bạn có thể sử dụng các biểu thức như vậy thay cho các tài liệu tham khảo cột bất cứ nơi nào chúng xảy ra trong các câu lệnh SQL.

Hai câu lệnh

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

9 được hiển thị ở đây tạo ra cùng một đầu ra:

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

Chức năng này không giới hạn ở

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

9, như được hiển thị ở đây:

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]

Điều này cũng hoạt động với các giá trị mảng JSON, như được hiển thị ở đây:

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Mảng lồng được hỗ trợ. Một biểu thức sử dụng

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

3 đánh giá là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6 nếu không tìm thấy phím phù hợp trong tài liệu JSON đích, như được hiển thị ở đây:

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Đây là hành vi tương tự như đã thấy trong những trường hợp như vậy khi sử dụng

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

________ 85->> ________ 42

Đây là một toán tử trích xuất được cải thiện, không thể chi tiết. Trong khi toán tử

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

3 chỉ cần trích xuất một giá trị, thì toán tử

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]

7 ngoài ra còn không kết quả trích xuất. Nói cách khác, được đưa ra giá trị cột

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]

9 và biểu thức đường dẫn

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 [một chuỗi chữ], ba biểu thức sau đây trả về cùng một giá trị:

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

01 JSON_EXTRACT [________ 99,

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2]]

JSON_EXTRACT[mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]
9,  ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']
2] ]

Json_unquote [________ 99

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

3  ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']
2]

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']
2]

________ 85->> ________ 42

Đây là một toán tử trích xuất được cải thiện, không thể chi tiết. Trong khi toán tử

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

3 chỉ cần trích xuất một giá trị, thì toán tử

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]

7 ngoài ra còn không kết quả trích xuất. Nói cách khác, được đưa ra giá trị cột

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]

9 và biểu thức đường dẫn

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 [một chuỗi chữ], ba biểu thức sau đây trả về cùng một giá trị:

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

01 JSON_EXTRACT [________ 99,

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2]]mysql client:

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Json_unquote [________ 99

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

Toán tử

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]

7 có thể được sử dụng bất cứ nơi nào

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

10 sẽ được cho phép. Điều này bao gồm [nhưng không giới hạn ở] Danh sách

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

9, các mệnh đề

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

12 và

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

13 và các điều khoản

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

14 và

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

15.

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Một vài câu lệnh tiếp theo cho thấy một số tương đương của nhà điều hành

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]

7 với các biểu thức khác trong máy khách MySQL:

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Xem lập chỉ mục một cột được tạo để cung cấp chỉ mục cột JSON, cho các câu lệnh SQL được sử dụng để tạo và điền vào bảng

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

17 trong tập hợp các ví dụ vừa hiển thị.

Toán tử này cũng có thể được sử dụng với các mảng JSON, như được hiển thị ở đây:

Như với

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

3, toán tử

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected [0.68 sec]
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set [0.00 sec]

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected [0.04 sec]

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set [0.00 sec]

7 luôn được mở rộng trong đầu ra của

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

20, như ví dụ sau đây chứng minh:

Điều này tương tự như cách MySQL mở rộng toán tử

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

3 trong cùng một trường hợp.

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

JSON_KEYS [________ 65 [,

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2]]

Trả về các khóa từ giá trị cấp cao nhất của đối tượng JSON dưới dạng mảng JSON, hoặc, nếu đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 được đưa ra, các phím cấp cao nhất từ đường dẫn đã chọn. Trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6 Nếu bất kỳ đối số nào là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6, đối số

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

5 không phải là đối tượng hoặc

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2, nếu được đưa ra, không định vị một đối tượng. Xảy ra lỗi nếu đối số

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

5 không phải là tài liệu JSON hợp lệ hoặc đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 không phải là biểu thức đường dẫn hợp lệ hoặc chứa ký tự đại diện

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

1 hoặc

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

Mảng kết quả trống nếu đối tượng được chọn trống. Nếu giá trị cấp cao nhất có các tiểu mục lồng nhau, giá trị trả về không bao gồm các khóa từ các tiểu mục đó.

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

33,

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

34]

So sánh hai tài liệu JSON. Trả về true [1] nếu hai tài liệu có bất kỳ cặp giá trị khóa hoặc phần tử mảng nào chung. Nếu cả hai đối số là vô hướng, hàm thực hiện một bài kiểm tra bình đẳng đơn giản. Nếu một trong hai đối số là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6, hàm trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Hàm này đóng vai trò là đối tác của

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

7, yêu cầu tất cả các phần tử của mảng được tìm kiếm để có mặt trong mảng được tìm kiếm. Do đó,

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

7 thực hiện hoạt động

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

39 trên các khóa tìm kiếm, trong khi

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

40 thực hiện thao tác

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

41.

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Khi so sánh các đối tượng, kết quả là đúng nếu chúng có ít nhất một cặp giá trị khóa chung.

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

Nếu hai vô hướng được sử dụng làm đối số cho hàm,

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

40 thực hiện một bài kiểm tra đơn giản cho sự bình đẳng:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

Khi so sánh vô hướng với một mảng,

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

40 cố gắng coi vô hướng như một phần tử mảng. Trong ví dụ này, đối số thứ hai

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

48 được hiểu là

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

49, như được hiển thị ở đây:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

Chức năng không thực hiện chuyển đổi loại:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

40 đã được thêm vào trong MySQL 8.0.17.

Json_search [________ 65,

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

0, ________ 153 [, ________ 154 [,  ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']
2] ...]]]]

Trả về đường dẫn đến chuỗi đã cho trong tài liệu JSON. Trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6 Nếu bất kỳ đối số

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

53 hoặc

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6; Không

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 tồn tại trong tài liệu; hoặc

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

53 không được tìm thấy. Xảy ra lỗi nếu đối số

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

5 không phải là tài liệu JSON hợp lệ, bất kỳ đối số

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 nào không phải là biểu thức đường dẫn hợp lệ,

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

0 không phải là

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

8 hoặc

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

9 hoặc

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

54 không phải là biểu thức không đổi.

Đối số

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

0 ảnh hưởng đến tìm kiếm như sau:

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

8: Tìm kiếm chấm dứt sau trận đấu đầu tiên và trả về một chuỗi đường dẫn. Nó không xác định được trận đấu nào được coi là đầu tiên.

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

9: Tìm kiếm trả về tất cả các chuỗi đường dẫn phù hợp sao cho không bao gồm các đường dẫn trùng lặp. Nếu có nhiều chuỗi, chúng được tự động tạo thành một mảng. Thứ tự của các phần tử mảng không được xác định.

Trong đối số chuỗi tìm kiếm

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

53, các ký tự

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

73 và

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

74 hoạt động như đối với toán tử

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

75:

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

73 khớp với bất kỳ số lượng ký tự nào [bao gồm cả ký tự bằng 0] và

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

74 khớp với chính xác một ký tự.

Để chỉ định ký tự

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

73 hoặc

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

74 theo nghĩa đen trong chuỗi tìm kiếm, đi trước nó bởi ký tự thoát. Mặc định là

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

80 nếu đối số

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

54 bị thiếu hoặc

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6. Nếu không,

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

54 phải là một hằng số trống hoặc một ký tự.

Để biết thêm thông tin về hành vi ký tự kết hợp và thoát, hãy xem mô tả của

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

75 trong Phần & NBSP; 12.8.1, Chức năng so sánh chuỗi và toán tử. Đối với việc xử lý ký tự thoát, một sự khác biệt so với hành vi

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

75 là ký tự thoát cho

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

86 phải đánh giá thành một hằng số tại thời điểm biên dịch, không chỉ vào thời điểm thực hiện. Ví dụ: nếu

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

86 được sử dụng trong một câu lệnh đã chuẩn bị và đối số

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

54 được cung cấp bằng tham số

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

89, giá trị tham số có thể không đổi vào thời điểm thực thi, nhưng không ở thời điểm biên dịch.

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

53 và

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 luôn được hiểu là chuỗi UTF8MB4, bất kể mã hóa thực tế của chúng. Đây là một vấn đề đã biết được cố định trong MySQL 8.0.24 [lỗi #32449181].

SELECT * FROM table_A where json like '%"dept_code": "012"%';

Để biết thêm thông tin về cú pháp JSON Path được hỗ trợ bởi MySQL, bao gồm các quy tắc điều chỉnh các nhà khai thác đại diện

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

1 và

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

2, xem cú pháp Path Path.

JSON_VALUE [________ 65,

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2]

Trích xuất một giá trị từ một tài liệu JSON tại đường dẫn được đưa ra trong tài liệu được chỉ định và trả về giá trị được trích xuất, tùy chọn chuyển đổi nó thành một loại mong muốn. Cú pháp hoàn chỉnh được hiển thị ở đây:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

5 là một tài liệu JSON hợp lệ. Nếu đây là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6, hàm trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 là một đường dẫn JSON chỉ vào một vị trí trong tài liệu. Đây phải là một giá trị theo nghĩa đen.

SELECT * FROM table_A where json like '%"dept_code": "012"%';

00 là một trong các loại dữ liệu sau:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

SELECT * FROM table_A where json like '%"dept_code": "012"%';

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

SELECT * FROM table_A where json like '%"dept_code": "012"%';

SELECT * FROM table_A where json like '%"dept_code": "012"%';

SELECT * FROM table_A where json like '%"dept_code": "012"%';

SELECT * FROM table_A where json like '%"dept_code": "012"%';

SELECT * FROM table_A where json like '%"dept_code": "012"%';

SELECT * FROM table_A where json like '%"dept_code": "012"%';

09 [MySQL 8.0,22 trở lên]

SELECT * FROM table_A where json like '%"dept_code": "012"%';

09 Giá trị của một hoặc hai chữ số không được hỗ trợ.

SELECT * FROM table_A where json like '%"dept_code": "012"%';

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

Các loại chỉ được liệt kê giống như các loại [không phải] được hỗ trợ bởi hàm

SELECT * FROM table_A where json like '%"dept_code": "012"%';

13.

Nếu không được chỉ định bởi mệnh đề

SELECT * FROM table_A where json like '%"dept_code": "012"%';

14, loại trả về của hàm

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 là

SELECT * FROM table_A where json like '%"dept_code": "012"%';

16. Khi không có bộ ký tự được chỉ định cho loại trả về,

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 sử dụng

SELECT * FROM table_A where json like '%"dept_code": "012"%';

18 với đối chiếu nhị phân, nhạy cảm với trường hợp; Nếu

SELECT * FROM table_A where json like '%"dept_code": "012"%';

18 được chỉ định là bộ ký tự cho kết quả, máy chủ sử dụng đối chiếu mặc định cho bộ ký tự này, không nhạy cảm trường hợp.

Khi dữ liệu tại đường dẫn được chỉ định bao gồm hoặc giải quyết thành chữ JSON null, hàm trả về SQL

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

SELECT * FROM table_A where json like '%"dept_code": "012"%';

21, nếu được chỉ định, xác định cách thức hoạt động

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 khi không tìm thấy dữ liệu nào ở đường dẫn được đưa ra; Điều khoản này có một trong các giá trị sau:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

23: Hàm trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6; Đây là hành vi

SELECT * FROM table_A where json like '%"dept_code": "012"%';

25 mặc định.

SELECT * FROM table_A where json like '%"dept_code": "012"%';

26 trên trống:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

27 được cung cấp được trả về. Loại giá trị phải khớp với loại trả về.

SELECT * FROM table_A where json like '%"dept_code": "012"%';

28: Hàm ném lỗi.

Nếu được sử dụng,

SELECT * FROM table_A where json like '%"dept_code": "012"%';

29 lấy một trong các giá trị sau với kết quả tương ứng khi xảy ra lỗi, như được liệt kê ở đây:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

30:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6; Đây là hành vi mặc định nếu không sử dụng mệnh đề

SELECT * FROM table_A where json like '%"dept_code": "012"%';

33.

```
SELECT * FROM table_A where json like '%"dept_code": "012"%';
```
26 trên lỗi: Đây là giá trị được trả về; Giá trị của nó phải phù hợp với loại trả về.

SELECT * FROM table_A where json like '%"dept_code": "012"%';

35: Một lỗi được ném.

SELECT * FROM table_A where json like '%"dept_code": "012"%';

36, nếu được sử dụng, phải đi trước bất kỳ mệnh đề

SELECT * FROM table_A where json like '%"dept_code": "012"%';

33 nào. Chỉ định chúng theo thứ tự sai dẫn đến lỗi cú pháp.

Xử lý lỗi. & Nbsp; Nói chung, các lỗi được xử lý bởi

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 như sau: In general, errors are handled by

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 as follows:

Tất cả đầu vào JSON [tài liệu và đường dẫn] được kiểm tra tính hợp lệ. Nếu bất kỳ trong số đó không hợp lệ, lỗi SQL được ném mà không kích hoạt mệnh đề
```
SELECT * FROM table_A where json like '%"dept_code": "012"%';
```
33.
```
SELECT * FROM table_A where json like '%"dept_code": "012"%';
```
33 được kích hoạt bất cứ khi nào bất kỳ sự kiện nào sau đây xảy ra:
- Cố gắng trích xuất một đối tượng hoặc một mảng, chẳng hạn như kết quả từ một đường dẫn giải quyết đến nhiều vị trí trong tài liệu JSON
- Lỗi chuyển đổi, chẳng hạn như cố gắng chuyển đổi
```
SELECT * FROM table_A where json like '%"dept_code": "012"%';
```
  41 thành giá trị
```
SELECT * FROM table_A where json like '%"dept_code": "012"%';
```
  05
- Cắt ngắn các giá trị

Lỗi chuyển đổi luôn kích hoạt cảnh báo ngay cả khi

SELECT * FROM table_A where json like '%"dept_code": "012"%';

30 hoặc

SELECT * FROM table_A where json like '%"dept_code": "012"%';

44 được chỉ định.

Điều khoản

SELECT * FROM table_A where json like '%"dept_code": "012"%';

36 được kích hoạt khi tài liệu JSON nguồn [

SELECT * FROM table_A where json like '%"dept_code": "012"%';

46] không chứa dữ liệu tại vị trí được chỉ định [

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2].

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 đã được giới thiệu trong MySQL 8.0.21.

Ví dụ. & NBSP; Hai ví dụ đơn giản được hiển thị ở đây: Two simple examples are shown here:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

Câu lệnh Chọn JSON_VALUE [________ 65,

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

2 Trả về

SELECT * FROM table_A where json like '%"dept_code": "012"%';

00] tương đương với câu lệnh sau:

SELECT
          JSON_VALUE[mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a', '$.e'] |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'];
+---------------------------------------------+
| JSON_CONTAINS_PATH[@j, 'all', '$.a', '$.e'] |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.c.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.c.d'] |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH[@j, 'one', '$.a.d'];
+----------------------------------------+
| JSON_CONTAINS_PATH[@j, 'one', '$.a.d'] |
+----------------------------------------+
|                                      0 |
+----------------------------------------+
5,  ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']
2 RETURNING SELECT * FROM table_A where json like '%"dept_code": "012"%';
00]

is equivalent to the following statement:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 đơn giản hóa việc tạo các chỉ mục trên các cột JSON bằng cách làm cho nó không cần thiết trong nhiều trường hợp để tạo một cột được tạo và sau đó là một chỉ mục trên cột được tạo. Bạn có thể làm điều này khi tạo bảng

SELECT * FROM table_A where json like '%"dept_code": "012"%';

53 có cột

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

4 bằng cách tạo một chỉ mục trên biểu thức sử dụng

SELECT * FROM table_A where json like '%"dept_code": "012"%';

15 hoạt động trên cột đó [với đường dẫn khớp với giá trị trong cột đó], như được hiển thị ở đây:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

Đầu ra

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

20 sau đây cho thấy rằng một truy vấn chống lại

SELECT * FROM table_A where json like '%"dept_code": "012"%';

53 Sử dụng biểu thức chỉ mục trong mệnh đề

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

12 sử dụng chỉ mục do đó được tạo:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

Điều này đạt được nhiều hiệu ứng tương tự như tạo bảng

SELECT * FROM table_A where json like '%"dept_code": "012"%';

59 với một chỉ mục trên một cột được tạo [xem lập chỉ mục một cột được tạo để cung cấp chỉ mục cột JSON], như cái này:

SELECT * FROM table_A where json like '%"dept_code": "012"%';

Đầu ra

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

20 cho truy vấn đối với bảng này, tham chiếu cột được tạo, cho thấy chỉ mục được sử dụng theo cách tương tự như đối với truy vấn trước đó đối với Bảng

SELECT * FROM table_A where json like '%"dept_code": "012"%';

53:

select * from table_A
where json_contains[json, '012', '$.dept_code']

Để biết thông tin về việc sử dụng các chỉ mục trên các cột được tạo để lập chỉ mục gián tiếp của các cột

mysql> SELECT c, JSON_EXTRACT[c, "$.id"], g
     > FROM jemp
     > WHERE JSON_EXTRACT[c, "$.id"] > 1
     > ORDER BY JSON_EXTRACT[c, "$.name"];
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set [0.00 sec]

4, hãy xem lập chỉ mục cột được tạo để cung cấp chỉ mục cột JSON.

SELECT * FROM table_A where json like '%"dept_code": "012"%';

27 Thành viên của [________ 264]

Trả về true [1] nếu

SELECT * FROM table_A where json like '%"dept_code": "012"%';

27 là một yếu tố của

SELECT * FROM table_A where json like '%"dept_code": "012"%';

64, nếu không thì trả về false [0].

SELECT * FROM table_A where json like '%"dept_code": "012"%';

27 phải là một tài liệu vô hướng hoặc JSON; Nếu đó là vô hướng, người vận hành sẽ cố gắng coi nó như một yếu tố của mảng JSON. Nếu

SELECT * FROM table_A where json like '%"dept_code": "012"%';

27 hoặc

SELECT * FROM table_A where json like '%"dept_code": "012"%';

64 là

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

6, hàm sẽ trả về

 ...WHERE JSON_CONTAINS[`json `, '{"dept_code " : "012"}']

Các truy vấn sử dụng

select * from table_A
where json_contains[json, '012', '$.dept_code']

9 trên các cột JSON của bảng

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.b'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.b'] |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.a'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.a'] |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS[@j, @j2, '$.c'];
+-------------------------------+
| JSON_CONTAINS[@j, @j2, '$.c'] |
+-------------------------------+
|                             1 |
+-------------------------------+

8 trong mệnh đề

SELECT * FROM table_A WHERE json = ...[looking dept_code = 012]...

12 có thể được tối ưu hóa bằng các chỉ mục đa giá trị. Xem các chỉ mục đa giá trị, để biết thông tin chi tiết và ví dụ.

Scalar đơn giản được coi là giá trị mảng, như được hiển thị ở đây:

select * from table_A
where json_contains[json, '012', '$.dept_code']

Các kết hợp một phần của các giá trị phần tử mảng không khớp:

select * from table_A
where json_contains[json, '012', '$.dept_code']

select * from table_A
where json_contains[json, '012', '$.dept_code']

Chuyển đổi sang và từ các loại chuỗi không được thực hiện:

select * from table_A
where json_contains[json, '012', '$.dept_code']

Để sử dụng toán tử này với một giá trị mà bản thân một mảng, cần phải đúc nó một cách rõ ràng dưới dạng mảng JSON. Bạn có thể làm điều này với

SELECT * FROM table_A where json like '%"dept_code": "012"%';

75:

select * from table_A
where json_contains[json, '012', '$.dept_code']

Cũng có thể thực hiện các diễn viên cần thiết bằng cách sử dụng hàm

SELECT * FROM table_A where json like '%"dept_code": "012"%';

76, như thế này:

select * from table_A
where json_contains[json, '012', '$.dept_code']

Bất kỳ đối tượng JSON nào được sử dụng làm giá trị sẽ được kiểm tra hoặc xuất hiện trong mảng đích phải được ép theo loại chính xác bằng cách sử dụng

SELECT * FROM table_A where json like '%"dept_code": "012"%';

75 hoặc

SELECT * FROM table_A where json like '%"dept_code": "012"%';

78. Ngoài ra, một mảng mục tiêu chứa các đối tượng JSON phải được sử dụng bằng cách sử dụng

SELECT * FROM table_A where json like '%"dept_code": "012"%';

79. Điều này được thể hiện trong chuỗi các câu sau đây:

select * from table_A
where json_contains[json, '012', '$.dept_code']

Toán tử

select * from table_A
where json_contains[json, '012', '$.dept_code']

9 đã được thêm vào trong MySQL 8.0.17.

`` Trong mysql là gì?

Mọi người sử dụng `` để bao quanh các tên trường và sử dụng '' cho các giá trị xung quanh. Đó có phải là sự thật? Hoặc lý do chính để làm như vậy là vì sau đó chúng ta có thể đặt mã vào một tệp văn bản và nhập vào cơ sở dữ liệu. Cảm ơn. mysql.

Làm cách nào để truy vấn một đối tượng JSON trong MySQL?

Đối với một đối tượng JSON, đường dẫn được chỉ định với $.Khóa, trong đó phím là khóa của đối tượng ...

Sử dụng $.....

Sử dụng $ [Index] để trích xuất giá trị của một phần tử từ mảng JSON ..

Sử dụng -> làm phím tắt cho json_extract nếu giá trị không phải là chuỗi ..

Chúng ta có thể lưu trữ dữ liệu JSON trong MySQL không?

MySQL hỗ trợ kiểu dữ liệu JSON gốc được xác định bởi RFC 7159 cho phép truy cập hiệu quả vào dữ liệu trong các tài liệu JSON [ký hiệu đối tượng JavaScript].Kiểu dữ liệu JSON cung cấp các lợi thế này so với việc lưu trữ các chuỗi định dạng JSON trong một cột chuỗi: Xác thực tự động các tài liệu JSON được lưu trữ trong các cột JSON. that enables efficient access to data in JSON [JavaScript Object Notation] documents. The JSON data type provides these advantages over storing JSON-format strings in a string column: Automatic validation of JSON documents stored in JSON columns.

Làm cách nào để truy vấn cột JSON trong MySQL?

MySQL cung cấp hai toán tử [ -> và ->>] để trích xuất dữ liệu từ các cột JSON.->> sẽ nhận được giá trị chuỗi trong khi -> sẽ tìm nạp giá trị mà không cần báo giá.Như bạn có thể thấy ->> trả về đầu ra dưới dạng chuỗi được trích dẫn, trong khi -> trả về các giá trị như hiện tại.Bạn cũng có thể sử dụng các toán tử này trong mệnh đề nơi như hình dưới đây.. ->> will get the string value while -> will fetch value without quotes. As you can see ->> returns output as quoted strings, while -> returns values as they are. You can also use these operators in WHERE clause as shown below.

`` Trong mysql là gì?

Làm cách nào để truy vấn một đối tượng JSON trong MySQL?

Chúng ta có thể lưu trữ dữ liệu JSON trong MySQL không?

Làm cách nào để truy vấn cột JSON trong MySQL?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề