Tipo de datos MySQL JSON
El tipo SON es un nuevo tipo de datos en MySQL versión 5.7. Hacer un buen uso del tipo de datos JSON puede resolver eficazmente muchos problemas prácticos en los negocios.
Cuando se utiliza el tipo de datos JSON, se recomienda utilizar MySQL 8.0.17 o superior, que tiene mejor rendimiento y también admite índices de valores múltiples;
La ventaja del tipo de datos JSON es que no es necesario predefinir columnas y los datos en sí son muy descriptivos;
No almacene datos con relaciones obvias en JSON, como saldo de usuario, nombre de usuario, tarjeta de identificación de usuario, etc. Estos son datos que cada usuario debe contener;
El tipo de datos JSON se recomienda para el almacenamiento de datos estáticos que no se actualizan con frecuencia.
tipo de datos JSON
mysql> create table json_user(id int primary key auto_increment, data json);
Query OK, 0 rows affected (0.09 sec)
mysql> insert into json_user values(0, '{
"name":"morris","age":18,"address":"china"}');
Query OK, 1 row affected (0.03 sec)
mysql> insert into json_user values(0, '{
"name":"tom","age":16,"mail":"[email protected]"}');
Query OK, 1 row affected (0.01 sec)
mysql> select * from json_user;
+----+---------------------------------------------------------+
| id | data |
+----+---------------------------------------------------------+
| 1 | {
"age": 18, "name": "morris", "address": "china"} |
| 2 | {
"age": 16, "mail": "[email protected]", "name": "tom"} |
+----+---------------------------------------------------------+
2 rows in set (0.01 sec)
Las funciones JSON comunes utilizan
json_extract para extraer campos
mysql> select json_extract('[1, 2, 3, [4, 5]]', '$[1]');
+-------------------------------------------+
| json_extract('[1, 2, 3, [4, 5]]', '$[1]') |
+-------------------------------------------+
| 2 |
+-------------------------------------------+
1 row in set (0.02 sec)
mysql> select json_extract('{
"age": 18, "name": "morris", "address": "china"}', '$.name');
+-----------------------------------------------------------------------------+
| json_extract('{
"age": 18, "name": "morris", "address": "china"}', '$.name') |
+-----------------------------------------------------------------------------+
| "morris" |
+-----------------------------------------------------------------------------+
1 row in set (0.00 sec)
mysql> select data->"$.name" from json_user;
+----------------+
| data->"$.name" |
+----------------+
| "morris" |
| "tom" |
+----------------+
2 rows in set (0.00 sec)
json_object convierte objetos a json
mysql> select json_object('name','bob','age','22','email','bob@sina.com');
+-------------------------------------------------------------+
| json_object('name','bob','age','22','email','bob@sina.com') |
+-------------------------------------------------------------+
| {
"age": "22", "name": "bob", "email": "[email protected]"} |
+-------------------------------------------------------------+
1 row in set (0.01 sec)
json_insert inserta la
clave de datos y la ignora si existe y la inserta si no existe.
mysql> select json_insert('{
"age": 18, "name": "morris", "address": "china"}', '$.male', 'male', '$.age', 22);
+-------------------------------------------------------------------------------------------------+
| json_insert('{
"age": 18, "name": "morris", "address": "china"}', '$.male', 'male', '$.age', 22) |
+-------------------------------------------------------------------------------------------------+
| {
"age": 18, "male": "male", "name": "morris", "address": "china"} |
+-------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
json_merge fusiona datos
json_merge (obsoleto) es similar a json_merge_preserve, las mismas claves se fusionarán en matrices.
La misma clave en json_merge_patch reemplazará la clave anterior con la clave posterior.
mysql> select json_merge_patch('{
"name": "enjoy"}', '{
"id": 47, "name":"morris"}');
+----------------------------------------------------------------------+
| json_merge_patch('{
"name": "enjoy"}', '{
"id": 47, "name":"morris"}') |
+----------------------------------------------------------------------+
| {
"id": 47, "name": "morris"} |
+----------------------------------------------------------------------+
1 row in set (0.00 sec)
mysql> select json_merge('{
"name": "enjoy"}', '{
"id": 47, "name":"morris"}');
+----------------------------------------------------------------+
| json_merge('{
"name": "enjoy"}', '{
"id": 47, "name":"morris"}') |
+----------------------------------------------------------------+
| {
"id": 47, "name": ["enjoy", "morris"]} |
+----------------------------------------------------------------+
1 row in set, 1 warning (0.00 sec)
mysql> select json_merge_preserve('{
"name": "enjoy"}', '{
"id": 47, "name":"morris"}');
+-------------------------------------------------------------------------+
| json_merge_preserve('{
"name": "enjoy"}', '{
"id": 47, "name":"morris"}') |
+-------------------------------------------------------------------------+
| {
"id": 47, "name": ["enjoy", "morris"]} |
+-------------------------------------------------------------------------+
1 row in set (0.00 sec)
Agregar elementos después de json_array_append
mysql> select json_array_append('["a", "b", "c"]', "$", "x");
+------------------------------------------------+
| json_array_append('["a", "b", "c"]', "$", "x") |
+------------------------------------------------+
| ["a", "b", "c", "x"] |
+------------------------------------------------+
1 row in set (0.00 sec)
Insertar elementos en json_array_insert
mysql> select json_array_insert('["a", "b", "c"]', "$[1]", "x");
+---------------------------------------------------+
| json_array_insert('["a", "b", "c"]', "$[1]", "x") |
+---------------------------------------------------+
| ["a", "x", "b", "c"] |
+---------------------------------------------------+
1 row in set (0.00 sec)
json_contains contiene una determinada subcadena json
mysql> select json_contains('{
"a":1,"b":4}','{
"a":1}');
+------------------------------------------+
| json_contains('{
"a":1,"b":4}','{
"a":1}') |
+------------------------------------------+
| 1 |
+------------------------------------------+
1 row in set (0.00 sec)
mysql> select json_contains('{
"age": 18, "name": "morris", "address": "china"}', '18', '$.name');
+------------------------------------------------------------------------------------+
| json_contains('{
"age": 18, "name": "morris", "address": "china"}', '18', '$.name') |
+------------------------------------------------------------------------------------+
| 0 |
+------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
json_array crea una matriz json
mysql> select json_array("a", "b", "c", "d");
+--------------------------------+
| json_array("a", "b", "c", "d") |
+--------------------------------+
| ["a", "b", "c", "d"] |
+--------------------------------+
1 row in set (0.00 sec)
json_contains_path determina si json contiene una determinada clave
mysql> select json_contains_path('{
"a": 1, "b": 2, "c": {
"d": 4}}', 'one', '$.a', '$.e');
+----------------------------------------------------------------------------+
| json_contains_path('{
"a": 1, "b": 2, "c": {
"d": 4}}', 'one', '$.a', '$.e') |
+----------------------------------------------------------------------------+
| 1 |
+----------------------------------------------------------------------------+
1 row in set (0.01 sec)
mysql> select json_contains_path('{
"a": 1, "b": 2, "c": {
"d": 4}}', 'all', '$.a', '$.e');
+----------------------------------------------------------------------------+
| json_contains_path('{
"a": 1, "b": 2, "c": {
"d": 4}}', 'all', '$.a', '$.e') |
+----------------------------------------------------------------------------+
| 0 |
+----------------------------------------------------------------------------+
1 row in set (0.00 sec)
json_keys consulta todas las claves de json
mysql> select json_keys('{
"a": 1, "b": 2, "c": {
"d": 4}}');
+----------------------------------------------+
| json_keys('{
"a": 1, "b": 2, "c": {
"d": 4}}') |
+----------------------------------------------+
| ["a", "b", "c"] |
+----------------------------------------------+
1 row in set (0.00 sec)
json_pretty formato json
mysql> select json_pretty('{
"a": 1, "b": 2, "c": {
"d": 4}}');
+-------------------------------------------------+
| json_pretty('{
"a": 1, "b": 2, "c": {
"d": 4}}') |
+-------------------------------------------------+
| {
"a": 1,
"b": 2,
"c": {
"d": 4
}
} |
+-------------------------------------------------+
1 row in set (0.00 sec)
json_ Depth consulta la profundidad de json
mysql> select json_depth('{
"a": 1, "b": 2, "c": {
"d": 4}}');
+-----------------------------------------------+
| json_depth('{
"a": 1, "b": 2, "c": {
"d": 4}}') |
+-----------------------------------------------+
| 3 |
+-----------------------------------------------+
1 row in set (0.00 sec)
json_length devuelve el número de elementos json
mysql> select json_length('{
"a": 1, "b": 2, "c": {
"d": 4}}');
+------------------------------------------------+
| json_length('{
"a": 1, "b": 2, "c": {
"d": 4}}') |
+------------------------------------------------+
| 3 |
+------------------------------------------------+
1 row in set (0.00 sec)
————————————————
json_remove elimina elementos según la clave
mysql> select json_remove('{
"a": 1, "b": 2, "c": {
"d": 4}}', "$.c");
+-------------------------------------------------------+
| json_remove('{
"a": 1, "b": 2, "c": {
"d": 4}}', "$.c") |
+-------------------------------------------------------+
| {
"a": 1, "b": 2} |
+-------------------------------------------------------+
1 row in set (0.00 sec)
json_replace reemplazar elemento
mysql> select json_replace('{
"a": 1, "b": 2, "c": {
"d": 4}}', "$.c", "cc");
+--------------------------------------------------------------+
| json_replace('{
"a": 1, "b": 2, "c": {
"d": 4}}', "$.c", "cc") |
+--------------------------------------------------------------+
| {
"a": 1, "b": 2, "c": "cc"} |
+--------------------------------------------------------------+
1 row in set (0.01 sec)
elemento de búsqueda json_search
mysql> select json_search('["abc", [{
"k": "10"}, "def"], {
"x":"abc"}, {
"y":"bcd"}]', 'one', 'abc');
+--------------------------------------------------------------------------------------+
| json_search('["abc", [{
"k": "10"}, "def"], {
"x":"abc"}, {
"y":"bcd"}]', 'one', 'abc') |
+--------------------------------------------------------------------------------------+
| "$[0]" |
+--------------------------------------------------------------------------------------+
1 row in set (0.01 sec)
mysql> select json_search('["abc", [{
"k": "10"}, "def"], {
"x":"abc"}, {
"y":"bcd"}]', 'all', 'abc');
+--------------------------------------------------------------------------------------+
| json_search('["abc", [{
"k": "10"}, "def"], {
"x":"abc"}, {
"y":"bcd"}]', 'all', 'abc') |
+--------------------------------------------------------------------------------------+
| ["$[0]", "$[2].x"] |
+--------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
json_set inserta elementos en json.
Si existe, se sobrescribirá. Si no existe, se agregará.
mysql> select json_set('{
"a": 1, "b": 2, "c": {
"d": 4}}', "$.a", "aaa", "$.e", "eee");
+-------------------------------------------------------------------------+
| json_set('{
"a": 1, "b": 2, "c": {
"d": 4}}', "$.a", "aaa", "$.e", "eee") |
+-------------------------------------------------------------------------+
| {
"a": "aaa", "b": 2, "c": {
"d": 4}, "e": "eee"} |
+-------------------------------------------------------------------------+
1 row in set (0.00 sec)
json_storage_size Ver el espacio ocupado por el almacenamiento json
mysql> select json_storage_size('{
"a": 1, "b": 2, "c": {
"d": 4}}');
+------------------------------------------------------+
| json_storage_size('{
"a": 1, "b": 2, "c": {
"d": 4}}') |
+------------------------------------------------------+
| 41 |
+------------------------------------------------------+
1 row in set (0.00 sec)
json_type consulta el tipo de json
mysql> select json_type('{
"a": 1, "b": 2, "c": {
"d": 4}}');
+----------------------------------------------+
| json_type('{
"a": 1, "b": 2, "c": {
"d": 4}}') |
+----------------------------------------------+
| OBJECT |
+----------------------------------------------+
1 row in set (0.01 sec)
json_valid determina si json es válido
mysql> select json_valid('{
"a": 1, "b": 2, "c": {
"d": 4}}');
+-----------------------------------------------+
| json_valid('{
"a": 1, "b": 2, "c": {
"d": 4}}') |
+-----------------------------------------------+
| 1 |
+-----------------------------------------------+
1 row in set (0.00 sec)
Índice JSON
Los datos de tipo JSON en sí no pueden crear un índice directamente. Es necesario regenerar columnas virtuales (columnas virtuales) a partir de los datos JSON que deben indexarse y luego indexar la columna.
mysql> create table test_json_index(id int primary key auto_increment, data json, gen_col varchar(10) generated always as (json_extract(data, '$.name')));
mysql> insert into test_json_index(data) values('{
"name":"morris","age":18,"address":"china"}');
mysql> insert into test_json_index(data) values('{
"name":"tom","age":16,"mail":"[email protected]"}');
mysql> select * from test_json_index;
+----+---------------------------------------------------------+----------+
| id | data | gen_col |
+----+---------------------------------------------------------+----------+
| 1 | {
"age": 18, "name": "morris", "address": "china"} | "morris" |
| 2 | {
"age": 16, "mail": "[email protected]", "name": "tom"} | "tom" |
+----+---------------------------------------------------------+----------+
mysql> select * from test_json_index where gen_col='morris'; -- 查不到数据
mysql> select * from test_json_index where gen_col='"morris"';
+----+---------------------------------------------------+----------+
| id | data | gen_col |
+----+---------------------------------------------------+----------+
| 1 | {
"age": 18, "name": "morris", "address": "china"} | "morris" |
+----+---------------------------------------------------+----------+
Si desea realizar consultas sin comillas, puede usar json_unquote para eliminar las comillas al agregar índices.
mysql> create table test_json_index2(id int primary key auto_increment, data json, gen_col varchar(10) generated always as (json_unquote(json_extract(data, '$.name'))));
Query OK, 0 rows affected (0.08 sec)
mysql> create table test_json_index3(id int primary key auto_increment, data json, gen_col varchar(10) generated always as (JSON_UNQUOTE(data->'$.name')));
Query OK, 0 rows affected (0.08 sec)
mysql> create table test_json_index4(id int primary key auto_increment, data json, gen_col varchar(10) generated always as (data->>'$.name'));
Query OK, 0 rows affected (0.05 sec)