In MariaDB, JSON_TABLE() ist eine integrierte Funktion, die JSON-Daten in eine relationale Form konvertiert.
Mit anderen Worten, Sie können damit ein JSON-Dokument als Tabelle zurückgeben.
Die JSON_TABLE() Funktion wurde in MariaDB 10.6.0 eingeführt.
Syntax
Die Syntax sieht so aus:
JSON_TABLE(json_doc,
context_path COLUMNS (column_list)
) [AS] alias
Wobei column_list geht so:
column[, column][, ...]
Wobei column geht so:
name FOR ORDINALITY
| name type PATH value_path path [on_empty] [on_error]
| name type EXISTS PATH value_path
| NESTED [PATH] path COLUMNS (column_list)
Wobei on_empty geht so:
{NULL | DEFAULT string | ERROR} ON EMPTY
Und on_error geht so:
{NULL | DEFAULT string | ERROR} ON ERRORBeispiel
Hier ist ein Beispiel zur Veranschaulichung.
SET @json_document = '
[
{ "name": "Wag", "type": "Dog", "weight": 20 },
{ "name": "Bark", "type": "Dog", "weight": 10 },
{ "name": "Meow", "type": "Cat", "weight": 7 }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
COLUMNS (
name VARCHAR(255) PATH '$.name',
type VARCHAR(50) PATH '$.type',
weight INT PATH '$.weight'
)
) AS json_table;Ergebnis:
+------+------+--------+ | name | type | weight | +------+------+--------+ | Wag | Dog | 20 | | Bark | Dog | 10 | | Meow | Cat | 7 | +------+------+--------+
Hier benennen wir jede Spalte für die Tabelle, geben ihren Datentyp an und geben dann den Pfad aus dem JSON-Dokument an, der für diese Spalte gilt.
Also haben wir unsere erste Spalte name genannt , und ordnete dann den Knoten mit dem Namen name zu aus dem JSON-Dokument in diese Spalte.
Ordinalitätsspalten
Der FOR ORDINALITY kann verwendet werden, um die Zeilen zu zählen, beginnend bei 1 .
SET @json_document = '
[
{ "name": "Scratch", "type": "Cat", "weight": 8 },
{ "name": "Bruce", "type": "Kangaroo", "weight": 100 },
{ "name": "Hop", "type": "Kangaroo", "weight": 130 }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
COLUMNS (
id FOR ORDINALITY,
name VARCHAR(255) PATH '$.name',
type VARCHAR(50) PATH '$.type',
weight INT PATH '$.weight'
)
) AS json_table;Ergebnis:
+------+---------+----------+--------+ | id | name | type | weight | +------+---------+----------+--------+ | 1 | Scratch | Cat | 8 | | 2 | Bruce | Kangaroo | 100 | | 3 | Hop | Kangaroo | 130 | +------+---------+----------+--------+
Überprüfen der Existenz eines Pfades
Sie können den EXISTS verwenden -Klausel, um zu prüfen, ob ein Pfad vorhanden ist. Wenn der Pfad im JSON-Dokument vorhanden ist, ist das Ergebnis 1 . Falls nicht vorhanden, 0 zurückgegeben wird.
SET @json_document = '
[
{ "name": "Punch", "type": "Kangaroo", "weight": 200 },
{ "name": "Snap", "type": "Cat", "weight": 12 },
{ "name": "Ruff", "type": "Dog" }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
COLUMNS (
name VARCHAR(255) PATH '$.name',
type VARCHAR(50) PATH '$.type',
has_weight INT EXISTS PATH '$.weight'
)
) AS json_table;Ergebnis:
+-------+----------+------------+ | name | type | has_weight | +-------+----------+------------+ | Punch | Kangaroo | 1 | | Snap | Cat | 1 | | Ruff | Dog | 0 | +-------+----------+------------+
Verschachtelte Pfade
Der NESTED PATH -Klausel können Sie mit verschachtelten JSON-Dokumenten umgehen. Wenn Sie diese Klausel verwenden, werden verschachtelte JSON-Strukturen in mehrere Zeilen konvertiert.
Beispiel:
SET @json_document = '
[
{ "product": "Left Handed Screwdriver", "sizes": [ "S", "M", "L" ] },
{ "product": "Long Weight", "sizes": [ "S", "L", "XL" ] },
{ "product": "Bottomless Coffee Cup" }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
COLUMNS (
product VARCHAR(255) PATH '$.product',
NESTED PATH '$.sizes[*]' columns (
size VARCHAR(2) PATH '$'
)
)
) AS json_table;Ergebnis:
+-------------------------+------+ | product | size | +-------------------------+------+ | Left Handed Screwdriver | S | | Left Handed Screwdriver | M | | Left Handed Screwdriver | L | | Long Weight | S | | Long Weight | L | | Long Weight | XL | | Bottomless Coffee Cup | NULL | +-------------------------+------+
Umgang mit leeren Pfaden
Der ON EMPTY -Klausel gibt an, was getan wird, wenn das vom Suchpfad angegebene Element im JSON-Dokument fehlt.
Beispiel:
SET @json_document = '
[
{ "name": "Punch", "type": "Kangaroo", "weight": 200 },
{ "name": "Snap", "type": "Cat", "weight": 12 },
{ "name": "Ruff"}
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
COLUMNS (
name VARCHAR(255) PATH '$.name',
type VARCHAR(50) PATH '$.type' DEFAULT "N/A" ON EMPTY,
weight INT PATH '$.weight'
)
) AS json_table;Ergebnis:
+-------+----------+--------+ | name | type | weight | +-------+----------+--------+ | Punch | Kangaroo | 200 | | Snap | Cat | 12 | | Ruff | N/A | NULL | +-------+----------+--------+
In diesem Beispiel Ruff hat kein Typfeld und daher N/A ist zurück gekommen. Das liegt daran, dass ich das im ON EMPTY angegeben habe Klausel für dieses Feld.
Umgang mit Fehlern
Der ON ERROR -Klausel gibt an, was getan werden soll, wenn beim Versuch, den Wert aus dem Dokument zu extrahieren, ein JSON-Strukturfehler auftritt.
Ein JSON-Strukturfehler tritt nur auf, wenn Sie versuchen, einen nicht skalaren JSON-Wert (Array oder Objekt) in einen skalaren Wert zu konvertieren. Wenn das ON ERROR Klausel ist nicht vorhanden, NULL ON ERROR ist impliziert.
Hier ist ein Beispiel für die Behandlung eines JSON-Strukturfehlers:
SET @json_document = '
[
{ "product": "Left Handed Screwdriver", "sizes": [ "S", "M", "L" ] },
{ "product": "Long Weight", "sizes": [ "S", "L", "XL" ] },
{ "product": "Bottomless Coffee Cup" }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
COLUMNS (
product VARCHAR(255) PATH '$.product',
sizes VARCHAR(5) PATH '$.sizes'
DEFAULT 'Oops!' ON ERROR
DEFAULT 'None' ON EMPTY
)
) AS json_table;Ergebnis:
+-------------------------+-------+ | product | sizes | +-------------------------+-------+ | Left Handed Screwdriver | Oops! | | Long Weight | Oops! | | Bottomless Coffee Cup | None | +-------------------------+-------+
Hier habe ich eine Zeichenfolge angegeben (Oops! ) zu verwenden, wenn ein JSON-Strukturfehler aufgetreten ist.
In diesem Fall habe ich auch den ON EMPTY eingefügt Klausel. Dies zeigt, dass sowohl der ON ERROR und der ON EMPTY -Klausel kann in derselben Anweisung verwendet werden.
Es ist jedoch wichtig zu beachten, dass ein Datentypkonvertierungsfehler (z. B. der Versuch, einen nicht ganzzahligen Wert in einem Ganzzahlfeld zu speichern, oder eine varchar-Spalte, die abgeschnitten wird) nicht als JSON-Fehler betrachtet wird und daher nicht den ON ERROR Klausel. Stattdessen werden Warnungen ausgegeben.
Hier ist ein Beispiel, um zu veranschaulichen, was ich meine:
SET @json_document = '
[
{ "name": "Punch", "type": "Kangaroo" },
{ "name": "Snap", "type": "Cat" },
{ "name": "Ruff", "type": "Dog" }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
COLUMNS (
name VARCHAR(255) PATH '$.name',
type INT PATH '$.type' DEFAULT 'Oops!' ON ERROR
)
) AS json_table;Ergebnis:
+-------+------+ | name | type | +-------+------+ | Punch | 0 | | Snap | 0 | | Ruff | 0 | +-------+------+ 3 rows in set, 3 warnings (0.000 sec)
Lassen Sie uns die Warnungen anzeigen:
SHOW WARNINGS;Ergebnis:
+---------+------+---------------------------------------------------------------------------------+ | Level | Code | Message | +---------+------+---------------------------------------------------------------------------------+ | Warning | 1366 | Incorrect integer value: 'Kangaroo' for column ``.`(temporary)`.`type` at row 1 | | Warning | 1366 | Incorrect integer value: 'Cat' for column ``.`(temporary)`.`type` at row 2 | | Warning | 1366 | Incorrect integer value: 'Dog' for column ``.`(temporary)`.`type` at row 3 | +---------+------+---------------------------------------------------------------------------------+
