sql >> Base de Datos >  >> RDS >> MariaDB

MariaDB JSON_SEARCH() explicado

En MariaDB, JSON_SEARCH() es una función integrada que le permite obtener la ruta a un valor dado en un documento JSON.

Acepta el documento JSON y una cadena como argumentos y devuelve la ruta a la cadena dada dentro del documento.

Sintaxis

La sintaxis es así:

JSON_SEARCH(
    json_doc, 
    return_arg, 
    search_str[, escape_char[, path] ...]
    )

Dónde:

  • json_doc es el documento JSON y search_str es la cadena.
  • return_arg es la palabra clave one o all . Si usas one , solo se devuelve la primera ruta. Cualquier otra ocurrencia es ignorada. La ruta que se considera "primera" no está definida (según la documentación de MariaDB). Si all se especifica, se devuelven las rutas de todas las apariciones. Si hay varias rutas, se ajustan automáticamente como una matriz.
  • El escape_char argumento es un carácter opcional para usar como carácter de escape.
  • La path argument es un argumento opcional para determinar dónde comienza la ruta de "nivel superior" dentro del documento JSON.

Ejemplo

Aquí hay un ejemplo para demostrarlo:

SET @json = '
    { 
        "name" : "Wag", 
        "type" : "Dog" 
    }';

SELECT JSON_SEARCH(@json, 'one', 'Wag');

Resultado:

+----------------------------------+
| JSON_SEARCH(@json, 'one', 'Wag') |
+----------------------------------+
| "$.name"                         |
+----------------------------------+

Aquí hay un ejemplo de devolver la ruta de un elemento en una matriz:

SET @json = '
    { 
        "product" : "Left Handed Screwdriver", 
        "sizes" : [ "Small", "Medium", "Large" ],
    }';

SELECT JSON_SEARCH(@json, 'one', 'Medium');

Resultado:

+-------------------------------------+
| JSON_SEARCH(@json, 'one', "Medium") |
+-------------------------------------+
| "$.sizes[1]"                        |
+-------------------------------------+

Las matrices están basadas en cero, por lo que $.sizes[1] se refiere al segundo elemento de la matriz.

Ocurrencias Múltiples

Si desea devolver todas las rutas que contienen la cadena, use all en lugar de one para el segundo argumento.

SET @json = '[
    { "name": "Wag", "type": "Dog", "weight": 20 },
    { "name": "Bark", "type": "Dog", "weight": 10 },
    { "name": "Meow", "type": "Cat", "weight": 7 }
]';

SELECT JSON_SEARCH(@json, 'all', 'Dog');

Resultado:

+----------------------------------+
| JSON_SEARCH(@json, 'all', "Dog") |
+----------------------------------+
| ["$[0].type", "$[1].type"]       |
+----------------------------------+

Si cambiamos all a one , esto es lo que sucede:

SET @json = '[
    { "name": "Wag", "type": "Dog", "weight": 20 },
    { "name": "Bark", "type": "Dog", "weight": 10 },
    { "name": "Meow", "type": "Cat", "weight": 7 }
]';

SELECT JSON_SEARCH(@json, 'one', 'Dog');

Resultado:

+----------------------------------+
| JSON_SEARCH(@json, 'one', "Dog") |
+----------------------------------+
| "$[0].type"                      |
+----------------------------------+

Solo se devuelve una ruta.

Especifique una ruta

Aquí hay un ejemplo que especifica una ruta para buscar dentro del documento:

SET @json = '
    { 
        "_id" : 1, 
        "name" : "Wag", 
        "details" : {
            "type" : "Dog", 
            "weight" : 20,
            "awards" : { 
                "NZ Dog Award" : "Top Dog", 
                "New York Marathon" : "Fastest Animal", 
                "Sumo 2021" : "Biggest Dog"
            }
        }
    }
';
SELECT JSON_SEARCH(
    @json, 
    'all',
    '%dog%',
    NULL,
    '$.details.awards'
    ) AS Result;

Resultado:

+-----------------------------------------------------------------+
| Result                                                          |
+-----------------------------------------------------------------+
| ["$.details.awards.NZ Dog Award", "$.details.awards.Sumo 2021"] |
+-----------------------------------------------------------------+

En este caso, la cadena dog en realidad ocurre tres veces dentro del documento, pero solo dos veces debajo de la ruta especificada.

Además, usamos NULL para el argumento del carácter de escape, lo que hace que se utilice el carácter de escape predeterminado, que es la barra invertida (\ ).

Carácter de escape predeterminado

De forma predeterminada, el carácter de escape es una barra invertida (\ ).

Ejemplo:

SET @json = '[
    { "uid": "Wag", "pwd": "my%pwd" },
    { "uid": "Bark", "pwd": "my%%%pwd" },
    { "uid": "Bark", "pwd": "myBIGpwd" }
]';

SELECT 
    JSON_SEARCH(@json, 'all', 'my%pwd') AS "Not Escaped",
    JSON_SEARCH(@json, 'all', 'my\%pwd') AS "Escaped";

Resultado:

+--------------------------------------+------------+
| Not Escaped                          | Escaped    |
+--------------------------------------+------------+
| ["$[0].pwd", "$[1].pwd", "$[2].pwd"] | "$[0].pwd" |
+--------------------------------------+------------+

El signo de porcentaje (% ) es un carácter comodín que coincide con cualquier número de caracteres. Por lo tanto, si no lo escapamos, coincidirá con cualquier número de caracteres, incluidos los caracteres que no son signos de porcentaje.

Pero cuando escapamos del signo de porcentaje con el carácter de escape, solo coincidirá cuando haya exactamente un signo de porcentaje en esa ubicación.

Los resultados anteriores reflejan esto.

Especifique un carácter de escape personalizado

Puede especificar un carácter de escape personalizado si es necesario. Para hacer esto, proporciónelo como el cuarto argumento.

Ejemplo:

SET @json = '[
    { "uid": "Wag", "pwd": "my%pwd" },
    { "uid": "Bark", "pwd": "my%%%pwd" },
    { "uid": "Bark", "pwd": "myBIGpwd" }
]';

SELECT 
    JSON_SEARCH(@json, 'all', 'my%pwd', '!') AS "Not Escaped",
    JSON_SEARCH(@json, 'all', 'my!%pwd', '!') AS "Escaped";

Resultado:

+--------------------------------------+------------+
| Not Escaped                          | Escaped    |
+--------------------------------------+------------+
| ["$[0].pwd", "$[1].pwd", "$[2].pwd"] | "$[0].pwd" |
+--------------------------------------+------------+

Entonces obtenemos el mismo resultado que en el ejemplo anterior. La única diferencia es que especificamos un carácter de escape diferente. En este caso, especificamos que el signo de exclamación (! ) es el carácter de escape.

Argumentos nulos

Si alguno de los argumentos de cadena de búsqueda, cadena de búsqueda o ruta es NULL , el resultado es NULL :

SELECT 
    JSON_SEARCH(null, 'all', 's', '', '$') AS a,
    JSON_SEARCH('{"a":1}', 'all', null, '', '$') AS b,
    JSON_SEARCH('{"a":1}', 'all', 's', '', null) AS c;

Resultado:

+------+------+------+
| a    | b    | c    |
+------+------+------+
| NULL | NULL | NULL |
+------+------+------+

Recuento de parámetros incorrecto

No proporcionar argumentos da como resultado un error:

SELECT JSON_SEARCH();

Resultado:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'JSON_SEARCH'

Es lo mismo cuando proporciona muy pocos argumentos:

SELECT JSON_SEARCH('{"a":1}', 'all');

Resultado:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'JSON_SEARCH'