SQLite JSON_EXTRACT()

I SQLite, json_extract() funktion extraherar och returnerar ett eller flera värden från välformad JSON.

Vi skickar JSON som ett argument när vi anropar funktionen, och den returnerar tillämpligt värde/värden.

Vi kan ange en eller flera sökvägar att extrahera från JSON-dokumentet.

Syntax

Syntaxen ser ut så här:

json_extract(X,P1,P2,...)

Där X representerar JSON-dokumentet och P1,P2,... är sökvägar som vi kan använda för att extrahera specifika delar av JSON-dokumentet.

Exempel

Här är ett grundläggande exempel att visa:

SELECT json_extract('{ "a" : 1 }', '$');

Resultat:

{"a":1}

Här angav jag sökvägen $ , som returnerar hela JSON-dokumentet.

Här är ett exempel med ett större JSON-dokument:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$'
);

Resultat:

{"dogs":[{"name":"Wag","scores":[7,9]},{"name":"Bark","scores":[3,4,8,7]},{"name":"Woof","scores":[3,2,1]}]}

Låt oss ändra sökvägen så att vi bara returnerar dogs array:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs'
);

Resultat:

[{"name":"Wag","scores":[7,9]},{"name":"Bark","scores":[3,4,8,7]},{"name":"Woof","scores":[3,2,1]}]

Låt oss välja ett av elementen i arrayen:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[1]'
);

Resultat:

{"name":"Bark","scores":[3,4,8,7]}

Matriser är nollbaserade, så räkningen börjar vid 0 . Därför angav vi [1] för att få det andra elementet inom dogs array, som råkar vara ett JSON-objekt.

Låt oss gå djupare igen och returnera bara namnet på hunden på den positionen i arrayen:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[1].name'
);

Resultat:

Bark

Ange flera sökvägar

json_extract() funktionen låter oss välja flera sökvägar:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[0].name',
'$.dogs[1].name',
'$.dogs[2].name'
);

Resultat:

["Wag","Bark","Woof"]

I det här fallet returnerade jag namnen på alla hundar i dogs array.

Alla hundnamn returneras i en array.

Välja en icke-existerande sökväg

Om vi ​​pekar på en sökväg som inte finns, null returneras.

Låt oss först ställa in .nullvalue till NULL :

.nullvalue NULL

.nullvalue dot-kommandot låter oss tillhandahålla en sträng som kommer att användas för att ersätta null-värden. Det är ett av flera sätt du kan ersätta null-värden med en sträng i SQLite. I det här fallet ställer jag in den till NULL . Nu kommer alla nollvärden att returnera NULL istället för ett tomt resultat.

Låt oss nu anropa json_extract() , men använd ett andra argument som pekar på en icke-existerande sökväg:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.cats'
);

Resultat:

NULL

Ogiltiga sökvägar

Vi får ett felmeddelande om vår väg inte är väl utformad:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'dogs'
);

Resultat:

Runtime error: JSON path error near 'dogs'

I det här fallet glömde jag att inkludera $. längst fram på stigen.

Ogiltiga JSON-dokument

Vi får också ett felmeddelande om att JSON inte är välformaterad:

SELECT json_extract('{ "Dogs" : }', 
'$'
);

Resultat:

Runtime error: malformed JSON

Den här gången berättar felet att vår JSON är felaktig.

Returtyper

SQLite-dokumentationen anger följande:

Om endast en enda sökväg P1 tillhandahålls, är SQL-datatypen för resultatet NULL för en JSON-noll, INTEGER eller REAL för ett JSON-numeriskt värde, ett INTEGER-noll för ett JSON-falskt värde, ett INTEGER-ett för ett JSON-truevärde, den deciterade texten för ett JSON-strängvärde och en textrepresentation för JSON-objekt- och matrisvärden. Om det finns flera sökvägsargument (P1, P2 och så vidare) returnerar denna rutin SQLite-text som är en välformad JSON-matris som innehåller de olika värdena.

MySQL-kompatibilitet

SQLite-dokumentationen varnar oss också för en subtil inkompatibilitet mellan SQLite- och MySQL-implementeringarna av json_extract() funktion.

Specifikt står det:

MySQL-versionen av json_extract() returnerar alltid JSON. SQLite-versionen av json_extract() returnerar bara JSON om det finns två eller flera PATH-argument (eftersom resultatet då är en JSON-array) eller om det enda PATH-argumentet refererar till en array eller ett objekt. I SQLite, om json_extract() bara har ett enda PATH-argument och den PATH refererar till en JSON-null eller en sträng eller ett numeriskt värde, returnerar json_extract() motsvarande SQL NULL-, TEXT-, INTEGER- eller REAL-värde.

I grund och botten blir denna skillnad endast uppenbar när man kommer åt enskilda värden inom JSON som är strängar eller NULL.