MariaDB JSON_TABLE() Forklaret

I MariaDB, JSON_TABLE() er en indbygget funktion, der konverterer JSON-data til en relationel form.

Med andre ord lader den dig returnere et JSON-dokument som en tabel.

JSON_TABLE() funktion blev introduceret i MariaDB 10.6.0.

Syntaks

Syntaksen ser sådan ud:

JSON_TABLE(json_doc, context_path COLUMNS (column_list)) [AS] alias

Hvor column_list går sådan her:

kolonne[, kolonne][, ...]

Hvor column går sådan her:

navn FOR ORDINALITET | navnetype PATH værdisti sti [on_empty] [on_error] | navnetype EKSISTERER STI værdisti | INDETET [STI] sti COLUMNS (column_list)

Hvor on_empty går sådan her:

{NULL | DEFAULT streng | FEJL} PÅ TOM

Og on_error går sådan her:

{NULL | DEFAULT streng | ERROR} ON ERROR

Eksempel

Her er et eksempel til at demonstrere.

SET @json_document ='[ { "name":"Wag", "type":"Hund", "weight":20 }, { "name":"Bark", "type":" Hund", "vægt":10 }, { "navn":"Mjav", "type":"Kat", "vægt":7 }]';VÆLG * FRA JSON_TABLE(@json_document, '$[*]' COLUMNS ( navn VARCHAR(255) PATH '$.name', skriv VARCHAR(50) PATH '$.type', vægt INT PATH '$.weight' )) AS json_table;

Resultat:

+------+------+--------+| navn | type | vægt |+------+------+--------+| Wag | Hund | 20 || Bark | Hund | 10 || Mjav | Kat | 7 |+------+------+--------+

Her navngiver vi hver kolonne for tabellen, specificerer dens datatype og angiver derefter stien fra JSON-dokumentet, der gælder for den kolonne.

Så vi kaldte vores første kolonne navn , og kortlagde derefter noden kaldet navn fra JSON-dokumentet til den kolonne.

Ordinalitetskolonner

FOR ORDINALITY mulighed kan bruges til at tælle rækkerne, startende fra 1 .

SET @json_document ='[ { "name":"Scratch", "type":"Kat", "vægt":8 }, { "name":"Bruce", "type":" Kangaroo", "weight":100 }, { "name":"Hop", "type":"Kænguru", "weight":130 }]';SELECT * FROM JSON_TABLE(@json_document, '$[*]' COLUMNS ( id FOR ORDINALITY, navn VARCHAR(255) PATH '$.name', skriv VARCHAR(50) PATH '$.type', vægt INT PATH '$.weight' )) AS json_table;

Resultat:

+------+--------+----------+--------+| id | navn | type | vægt |+------+--------+----------+--------+| 1 | Ridse | Kat | 8 || 2 | Bruce | Kænguru | 100 || 3 | Hop | Kænguru | 130 |+------+--------+----------+--------+

Kontrol af, om der findes en sti

Du kan bruge koden EXISTS klausul for at kontrollere, om der findes en sti. Hvis stien findes i JSON-dokumentet, er resultatet 1 . Hvis det ikke findes, 0 er returneret.

SET @json_document ='[ { "name":"Punch", "type":"Kænguru", "vægt":200 }, { "name":"Snap", "type":" Cat", "weight":12 }, { "name":"Ruff", "type":"Dog" }]';SELECT * FROM JSON_TABLE(@json_document, '$[*]' COLUMNS ( navn VARCHAR(255) ) PATH '$.name', skriv VARCHAR(50) PATH '$.type', has_weight INT EKSISTERER PATH '$.weight' )) AS json_table;

Resultat:

+-------+-----------+--------+| navn | type | har_vægt |+-------+-----------------+| Punch | Kænguru | 1 || Snap | Kat | 1 || Ruff | Hund | 0 |+-------+-----------+------------+

Indlejrede stier

NESTED PATH klausul giver dig mulighed for at håndtere indlejrede JSON-dokumenter. Når du bruger denne klausul, konverterer den indlejrede JSON-strukturer til flere rækker.

Eksempel:

SET @json_document ='[ { "product":"Venstrehåndsskruetrækker", "størrelser":[ "S", "M", "L" ] }, { "product":"Lang vægt ", "sizes":[ "S", "L", "XL" ] }, { "product":"Bundløs kaffekop" }]';SELECT * FROM JSON_TABLE(@json_document, '$[*]' COLUMNS ( produkt VARCHAR(255) PATH '$.product', NESTED PATH '$.sizes[*]'-kolonner (størrelse VARCHAR(2) PATH '$' ) )) AS json_table;

Resultat:

+------------------------+-----+| produkt | størrelse |+-------------------------+------+| Venstrehåndsskruetrækker | S || Venstrehåndsskruetrækker | M || Venstrehåndsskruetrækker | L || Lang vægt | S || Lang vægt | L || Lang vægt | XL || Bundløs kaffekop | NULL |+-------------------------+-----+

Håndtering af tomme stier

ON EMPTY klausul specificerer, hvad der vil blive gjort, når elementet angivet af søgestien mangler i JSON-dokumentet.

Eksempel:

SET @json_document ='[ { "name":"Punch", "type":"Kænguru", "vægt":200 }, { "name":"Snap", "type":" Cat", "weight":12 }, { "name":"Ruff"}]';SELECT * FROM JSON_TABLE(@json_document, '$[*]' COLUMNS (navn VARCHAR(255) PATH '$.name', type VARCHAR(50) PATH '$.type' DEFAULT "N/A" PÅ TOM, vægt INT PATH '$.weight' )) AS json_table;

Resultat:

+-------+----------+--------+| navn | type | vægt |+-------+----------+--------+| Punch | Kænguru | 200 || Snap | Kat | 12 || Ruff | N/A | NULL |+------+----------+--------+

I dette eksempel Ruff har ikke et typefelt og derfor N/A er returneret. Dette er fordi jeg har specificeret det i ON EMPTY klausul for det felt.

Håndtering af fejl

ON ERROR klausul specificerer, hvad der skal gøres, hvis der opstår en JSON-strukturfejl, når du forsøger at udtrække værdien fra dokumentet.

En JSON-strukturfejl opstår kun, når du forsøger at konvertere en ikke-skalær JSON (array eller objekt) til en skalarværdi. Når ON ERROR klausul er ikke til stede, NULL ON ERROR er underforstået.

Her er et eksempel på håndtering af en JSON-strukturfejl:

SET @json_document ='[ { "product":"Venstrehåndsskruetrækker", "størrelser":[ "S", "M", "L" ] }, { "product":"Lang vægt ", "sizes":[ "S", "L", "XL" ] }, { "product":"Bundløs kaffekop" }]';SELECT * FROM JSON_TABLE(@json_document, '$[*]' COLUMNS ( produkt VARCHAR(255) PATH '$.product', størrelser VARCHAR(5) PATH '$.sizes' DEFAULT 'Ups!' PÅ FEJL STANDARD 'Ingen' PÅ TOM )) AS json_table;

Resultat:

+------------------------+------+| produkt | størrelser |+-------------------------+------+| Venstrehåndsskruetrækker | Ups! || Lang vægt | Ups! || Bundløs kaffekop | Ingen |+-------------------------+------+

Her specificerede jeg en streng (Ups! ) til brug, når der opstod en JSON-strukturfejl.

I dette tilfælde inkluderede jeg også ON EMPTY klausul. Dette viser, at både ON ERROR og ON EMPTY klausul kan bruges i samme sætning.

Det er dog vigtigt at bemærke, at en datatypekonverteringsfejl (f.eks. et forsøg på at gemme en ikke-heltalsværdi i et heltalsfelt, eller en varchar kolonne, der afkortes) ikke betragtes som en JSON-fejl og vil derfor ikke udløse PÅ FEJL klausul. I stedet vil det producere advarsler.

Her er et eksempel for at illustrere, hvad jeg mener:

SET @json_document ='[ { "name":"Punch", "type":"Kænguru" }, { "name":"Snap", "type":"Kat" }, { " name":"Ruff", "type":"Hund" }]';SELECT * FROM JSON_TABLE(@json_document, '$[*]' COLUMNS (navn VARCHAR(255) PATH '$.name', skriv INT PATH ' $.type' STANDARD 'Ups!' PÅ FEJL )) AS json_table;

Resultat:

+-------+------+| navn | skriv |+-------+------+| Punch | 0 || Snap | 0 || Ruff | 0 |+-------+------+3 rækker i sæt, 3 advarsler (0.000 sek.)

Lad os vise advarslerne:

VIS ADVARSLER;

Resultat:

+--------+------+------------------------------------- -------------------------------------------------- --+| Niveau | Kode | Besked |+--------+------+-------------------------------------- -------------------------------------------------- -+| Advarsel | 1366 | Forkert heltalsværdi:'Kænguru' for kolonne "`.`(midlertidig)`.`type` i række 1 || Advarsel | 1366 | Forkert heltalsværdi:'Cat' for kolonnen ``.`(midlertidig)`.`type` i række 2 || Advarsel | 1366 | Forkert heltalsværdi:'Hund' for kolonnen ``.`(midlertidig)`.`type` i række 3 |+---------+------+------- -------------------------------------------------- ------------------------+