MariaDB JSON_SEARCH() Förklarad

I MariaDB, JSON_SEARCH() är en inbyggd funktion som låter dig få sökvägen till ett givet värde i ett JSON-dokument.

Den accepterar JSON-dokumentet och en sträng som argument och returnerar sökvägen till den givna strängen i dokumentet.

Syntax

Syntaxen ser ut så här:

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

Var:

json_doc är JSON-dokumentet och search_str är strängen.
return_arg är nyckelordet one eller all . Om du använder one , endast den första sökvägen returneras. Alla andra händelser ignoreras. Vilken sökväg som anses vara "först" är odefinierad (enligt MariaDB-dokumentationen). Om all är specificerad, returneras sökvägarna för alla förekomster. Om det finns flera sökvägar, radbryts de automatiskt som en array.
escape_char argument är ett valfritt tecken att använda som ett escape-tecken.
path argument är ett valfritt argument för att avgöra var "top-level"-sökvägen börjar i JSON-dokumentet.

Exempel

Här är ett exempel att visa:

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

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

Resultat:

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

Här är ett exempel på att returnera sökvägen för ett element i en array:

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

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

Resultat:

+---------------------------------------------+| JSON_SEARCH(@json, 'one', "Medium") |+---------------------------------------- --+| "$.sizes[1]" |+--------------------------------------------+ 
 Arrayer är nollbaserade, och så $.sizes[1] hänvisar till det andra elementet i arrayen.
 Flera förekomster
 
 Om du vill returnera alla sökvägar som innehåller strängen, använd all istället för one för det andra argumentet.
 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'); 
 
 Resultat:
 +------------------------------------------+| JSON_SEARCH(@json, 'alla', "Hund") |+----------------------------------------+ | ["$[0].type", "$[1].type"] |+------------------------------------ -----+
 
 Om vi ändrar all till one , här är vad som händer:
 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'); 
 
 Resultat:
 +------------------------------------------+| JSON_SEARCH(@json, 'en', "Hund") |+----------------------------------------+ | "$[0].type" |+----------------------------------------+
 
 Endast en väg returneras. 
 Ange en sökväg
 
 Här är ett exempel som anger en sökväg för att söka i dokumentet:
 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; 
 
 Resultat:
 +------------------------------------------------------ ------------------+| Resultat |+------------------------------------------------------ ------------------+| ["$.details.awards.NZ Dog Award", "$.details.awards.Sumo 2021"] |+------------------------ ------------------------------------------+
 
 I det här fallet, strängen dog förekommer faktiskt tre gånger i dokumentet, men bara två gånger under den angivna sökvägen.
 
 Vi använde också NULL för escape-teckenargumentet, vilket resulterar i att standard escape-tecknet används, vilket är omvänt snedstreck (\ ). 
 Standard Escape-tecken
 
 Som standard är escape-tecknet ett omvänt snedstreck (\ ). 
 
 Exempel:
 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"; 
 
 Resultat:
 +----------------------------------------------+------- -----+| Ej undkom | Escaped |+-----------------------------------------------------+-------- ----+| ["$[0].pwd", "$[1].pwd", "$[2].pwd"] | "$[0].pwd" |+---------------------------------------------+- -----------+
 
 Procenttecknet (% ) är ett jokertecken som matchar valfritt antal tecken. Därför, om vi inte undkommer det, kommer det att matcha valfritt antal tecken, inklusive tecken som inte är procenttecken.
 
 Men när vi escaper procenttecknet med escape-tecknet kommer det bara att matcha när det finns exakt ett procenttecken på den platsen. 
 
 Resultaten ovan återspeglar detta.
 Ange en anpassad escape-tecken
 
 Du kan ange ett anpassat escape-tecken om det behövs. För att göra detta, ange det som det fjärde argumentet.
 
 Exempel:
 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"; 
 
 Resultat:
 +----------------------------------------------+------- -----+| Ej undkom | Escaped |+-----------------------------------------------------+-------- ----+| ["$[0].pwd", "$[1].pwd", "$[2].pwd"] | "$[0].pwd" |+---------------------------------------------+- -----------+
 
 Så vi får samma resultat som i föregående exempel. Den enda skillnaden är att vi angav en annan escape-karaktär. I det här fallet angav vi att utropstecken (! ) är flykttecken.
 Nollargument
 
 Om någon av söksträngen, söksträngen eller sökvägsargumenten är NULL , resultatet är 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; 
 
 Resultat:
 +------+------+------+| en | b | c |+------+------+------+| NULL | NULL | NULL |+------+------+------+
 Felaktig parameterräkning
 
 Att inte tillhandahålla några argument resulterar i ett fel:
 SELECT JSON_SEARCH(); 
 
 Resultat:
 ERROR 1582 (42000):Fel parameterantal i anropet till den inbyggda funktionen 'JSON_SEARCH'
 
 Det är samma sak när du ger för få argument:
 SELECT JSON_SEARCH('{"a":1}', 'all'); 
 
 Resultat:
 ERROR 1582 (42000):Fel parameterantal i anropet till den inbyggda funktionen 'JSON_SEARCH'