JSON_SEARCH() – Vind het pad naar een string in een JSON-document in MySQL

In MySQL is de JSON_SEARCH() functie retourneert het pad naar een gegeven string in een JSON-document.

U geeft het JSON-document op als argument voor de functie. U geeft ook het argument op dat bepaalt in welke tekenreeks moet worden gezocht (inclusief eventuele escapetekens), evenals een trefwoord om aan te geven of het pad van alle instanties of slechts één moet worden geretourneerd.

Syntaxis

De syntaxis gaat als volgt:

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

Uitleg van elk argument volgt.

json_doc is het JSON-document om te zoeken
one_or_all is het sleutelwoord one of all . Als u one . gebruikt , wordt het zoeken gestopt zodra het eerste exemplaar is gevonden. Dat wil zeggen, de functie retourneert alleen het pad van de eerste instantie van de zoekreeks. Als all is opgegeven, worden de paden van alle instanties geretourneerd, zodat er geen dubbele paden worden opgenomen. Als er meerdere paden zijn, worden ze automatisch ingepakt als een array.
search_str is de daadwerkelijke tekenreeks waarvan het pad moet worden geretourneerd.
escape_char is een optioneel teken om als escape-teken te gebruiken. Het moet een constante zijn die leeg is of één teken. Als u dit argument niet opgeeft (of als het NULL is), is het escape-teken de backslash (\ ).
path is een optioneel argument om te bepalen waar het pad op het hoogste niveau begint in het JSON-document.

Binnen de search_str argument, de % en _ tekens werken net als wanneer ze worden gebruikt met de LIKE operator:% komt overeen met een willekeurig aantal tekens (inclusief nul tekens), en _ komt exact overeen met één teken.

Een letterlijke % opgeven of _ teken in de zoekreeks, laat het voorafgaan door het escape-teken.

Voorbeeld 1 – Basisgebruik

Hier is een voorbeeld om te demonstreren.

SELECT 
  JSON_SEARCH('{"Name": "Bart", "Age": 10}', 'one', 'Bart') Result;

Resultaat:

+----------+
| Result   |
+----------+
| "$.Name" |
+----------+

Voorbeeld 2 – Arrays

Hier is een voorbeeld van het vinden van een string in een array.

SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Mischief') Result;

Resultaat:

+----------------+
| Result         |
+----------------+
| "$.Hobbies[1]" |
+----------------+

Arrays gebruiken op nul gebaseerde nummering, dus dit resultaat geeft het tweede element aan.

Voorbeeld 3 – Niet-bestaande string

Als u een tekenreeks opgeeft die niet bestaat, wordt een NULL-waarde geretourneerd.

SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Homer') Result;

Resultaat:

+--------+
| Result |
+--------+
| NULL   |
+--------+

U krijgt ook een NULL-waarde als een van de json_doc , search_str , of path argumenten zijn NULL of als er geen pad bestaat binnen het JSON-object.

Voorbeeld 4 – Meerdere keren dat een string voorkomt

Als het JSON-document meerdere exemplaren van dezelfde tekenreeks bevat, hangt het resultaat ervan af of u one opgeeft. of all als het tweede argument.

Als u one . gebruikt , alleen het eerste exemplaar wordt geretourneerd (ervan uitgaande dat er ten minste één exemplaar is):

SET @doc = '{"Name": "Bart", "Friends": ["Bart", "Milhouse"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Bart') Result;

Resultaat:

+----------+
| Result   |
+----------+
| "$.Name" |
+----------+

Als u all gebruikt , worden de paden van alle exemplaren geretourneerd. Als er meer dan één pad is, worden ze automatisch verpakt als een array.

SET @doc = '{"Name": "Bart", "Friends": ["Bart", "Milhouse"]}';
SELECT JSON_SEARCH(@doc, 'all', 'Bart') Result;

Resultaat:

+----------------------------+
| Result                     |
+----------------------------+
| ["$.Name", "$.Friends[0]"] |
+----------------------------+

U kunt ook een pad opgeven dat alleen die resultaten van een opgegeven pad retourneert. Meer daarover hieronder (onder Voorbeeld 8 – Geef een pad op ).

Voorbeeld 5 – Jokertekens

U kunt jokertekens gebruiken zoals gespecificeerd in de bovenstaande syntaxis. U kunt bijvoorbeeld de % . gebruiken overeenkomen met een willekeurig aantal tekens.

SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Skate%') Result;

Resultaat:

+----------------+
| Result         |
+----------------+
| "$.Hobbies[0]" |
+----------------+

En je kunt _ . gebruiken om slechts met één teken overeen te komen.

SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Bar_') Result;

Resultaat:

+----------+
| Result   |
+----------+
| "$.Name" |
+----------+

Als we de _ . zouden gebruiken in het vorige voorbeeld zouden we een NULL-resultaat krijgen.

SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Skate_') Result;

Resultaat:

+--------+
| Result |
+--------+
| NULL   |
+--------+

Voorbeeld 6 – Standaard Escape-teken

Als u moet zoeken naar een tekenreeks die daadwerkelijk een van de bovenstaande jokertekens bevat, moet u het teken escapen. Dat vertelt MySQL om het te gebruiken als een letterlijke tekenreeks (in plaats van het te interpreteren als een jokerteken).

SET @doc = '{"userid": "bart_simpson", "pwd": "pass%word"}';
SELECT JSON_SEARCH(@doc, 'one', 'pass\%word') Result;

Resultaat:

+---------+
| Result  |
+---------+
| "$.pwd" |
+---------+

Op het eerste gezicht denk je misschien dat de backslash niet nodig was, want als we dit zouden doen, zouden we tenslotte hetzelfde resultaat krijgen:

SET @doc = '{"userid": "bart_simpson", "pwd": "pass%word"}';
SELECT JSON_SEARCH(@doc, 'one', 'pass%word') Result;

Resultaat:

+---------+
| Result  |
+---------+
| "$.pwd" |
+---------+

Maar het probleem met deze aanpak is dat we ook hetzelfde resultaat krijgen als we dit doen:

SET @doc = '{"userid": "bart_simpson", "pwd": "pass%BLAH-BLAH-BLAH-word"}';
SELECT JSON_SEARCH(@doc, 'one', 'pass%word') 'Result';

Resultaat:

+---------+
| Result  |
+---------+
| "$.pwd" |
+---------+

Dus de backslash informeert MySQL dat we alleen op zoek zijn naar een enkele instantie van % als een letterlijke tekenreeks, en niet voor een willekeurig aantal andere tekens.

Hetzelfde concept geldt voor het onderstrepingsteken.

Als we dit doen:

SET @doc = '{"userid": "bart_simpson", "pwd": "pass%word"}';
SELECT 
  JSON_SEARCH(@doc, 'one', 'bart\_simpson') 'Escaped',
  JSON_SEARCH(@doc, 'one', 'bart_simpson') 'Not Escaped';

We krijgen dit:

+------------+-------------+
| Escaped    | Not Escaped |
+------------+-------------+
| "$.userid" | "$.userid"  |
+------------+-------------+

Beide benaderingen geven hetzelfde resultaat.

Maar als we dit doen (vervang de _ door J in de gebruikers-ID):

SET @doc = '{"userid": "bartJsimpson", "pwd": "pass%word"}';
SELECT 
  JSON_SEARCH(@doc, 'one', 'bart\_simpson') 'Escaped',
  JSON_SEARCH(@doc, 'one', 'bart_simpson') 'Not Escaped';

We krijgen dit:

+---------+-------------+
| Escaped | Not Escaped |
+---------+-------------+
| NULL    | "$.userid"  |
+---------+-------------+

Voorbeeld 7 – Aangepast Escape-teken

U kunt indien nodig uw eigen escape-teken opgeven. U doet dit door het op te nemen als een optioneel vierde argument.

Hier is het vorige voorbeeld herschreven om een ander escape-teken te gebruiken (de gebruikers-ID bevat een _ karakter).

SET @doc = '{"userid": "bart_simpson", "pwd": "pass%word"}';
SELECT 
  JSON_SEARCH(@doc, 'one', 'bart$_simpson', '$') 'Escaped',
  JSON_SEARCH(@doc, 'one', 'bart_simpson') 'Not Escaped';

Resultaat:

+------------+-------------+
| Escaped    | Not Escaped |
+------------+-------------+
| "$.userid" | "$.userid"  |
+------------+-------------+

En als we de _ . vervangen met J in het gebruikers-ID:

SET @doc = '{"userid": "bartJsimpson", "pwd": "pass%word"}';
SELECT 
  JSON_SEARCH(@doc, 'one', 'bart$_simpson', '$') 'Escaped',
  JSON_SEARCH(@doc, 'one', 'bart_simpson') 'Not Escaped';

Resultaat:

+---------+-------------+
| Escaped | Not Escaped |
+---------+-------------+
| NULL    | "$.userid"  |
+---------+-------------+

Voorbeeld 8 – Geef een pad op

U kunt ook een pad opgeven van waaruit u wilt beginnen met zoeken. Hier is een voorbeeld.

SET @data = '{  
    "Person": {    
       "Name": "Bart", 
       "Age": 10,
       "Friends": ["Bart", "Milhouse"]  
    }
 }';
SELECT JSON_SEARCH(@data, 'all', 'Bart', NULL, '$.Person.Friends') AS 'Result';

Resultaat:

+-----------------------+
| Result                |
+-----------------------+
| "$.Person.Friends[0]" |
+-----------------------+

Als we geen pad hadden opgegeven, zouden we het volgende resultaat krijgen.

SET @data = '{  
    "Person": {    
       "Name": "Bart", 
       "Age": 10,
       "Friends": ["Bart", "Milhouse"]  
    }
 }';
SELECT JSON_SEARCH(@data, 'all', 'Bart') AS 'Result';

Resultaat:

+------------------------------------------+
| Result                                   |
+------------------------------------------+
| ["$.Person.Name", "$.Person.Friends[0]"] |
+------------------------------------------+

Bovendien, als we one . hadden gespecificeerd als tweede argument (evenals het weglaten van het padargument), zouden we eindigen met het volgende.

SET @data = '{  
    "Person": {    
       "Name": "Bart", 
       "Age": 10,
       "Friends": ["Bart", "Milhouse"]  
    }
 }';
SELECT JSON_SEARCH(@data, 'one', 'Bart') AS 'Result';

Resultaat:

+-----------------+
| Result          |
+-----------------+
| "$.Person.Name" |
+-----------------+

Voorbeeld 9 – Leeg document

Als het document geen paden bevat, krijgt u een NULL-waarde.

SELECT 
  JSON_SEARCH('{}', 'all', 'Bart') 'Result';

Resultaat:

+--------+
| Result |
+--------+
| NULL   |
+--------+