So verwenden Sie allgemeine MySQL-Funktionen zur Verarbeitung von JSON

So verwenden Sie allgemeine MySQL-Funktionen zur Verarbeitung von JSON

Offizielle Dokumentation: JSON-Funktionen

Name Beschreibung
JSON_APPEND() Daten an JSON-Dokument anhängen
JSON_ARRAY() JSON-Array erstellen
JSON_ARRAY_APPEND() Daten an JSON-Dokument anhängen
JSON_ARRAY_INSERT() In JSON-Array einfügen
-> Gibt nach der Auswertung des Pfads einen Wert aus der JSON-Spalte zurück; entspricht JSON_EXTRACT().
JSON_CONTAINS() Ob ein JSON-Dokument ein bestimmtes Objekt unter dem Pfad enthält
JSON_CONTAINS_PATH() Ob das JSON-Dokument Daten im Pfad enthält
JSON_DEPTH() Maximale Tiefe des JSON-Dokuments
JSON_EXTRACT() Daten aus JSON-Dokument zurückgeben
->> Gibt den Wert aus der JSON-Spalte zurück, nachdem der Pfad ausgewertet und die Anführungszeichen im Ergebnis entfernt wurden; entspricht JSON_UNQUOTE(JSON_EXTRACT()).
JSON_INSERT() Daten in JSON-Dokument einfügen
JSON_KEYS() Array von Schlüsseln aus einem JSON-Dokument
JSON_LENGTH() Anzahl der Elemente im JSON-Dokument
JSON_MERGE() JSON-Dokumente zusammenführen
JSON_OBJECT() JSON-Objekt erstellen
JSON_QUOTE() Zitat JSON-Dokument
JSON_REMOVE() Daten aus JSON-Dokument entfernen
JSON_REPLACE() Werte im JSON-Dokument ersetzen
JSON_SEARCH() Pfad zum Wert im JSON-Dokument
JSON_SET() Daten in JSON-Dokument einfügen
JSON_TYPE() Typ des JSON-Wertes
JSON_UNQUOTE() Anführungszeichen für JSON-Wert entfernen
JSON_VALID() Ob der JSON-Wert gültig ist

1. Übersicht

Das JSON in MySQL ist in JSON-Arrays und JSON-Objekte unterteilt. $ stellt das gesamte JSON-Objekt dar. Verwenden Sie beim Indizieren von Daten den Index (beginnen Sie bei einem JSON-Array bei 0) oder den Schlüsselwert (bei einem JSON-Objekt sollten Schlüssel mit Sonderzeichen in " eingeschlossen werden, z. B. $."mein Name").

Zum Beispiel: [3, {"a": [5, 6], "b": 10}, [99, 100]], dann:

$[0]:3

$[1]: {"a": [5, 6], "b": 10}

$[2] ：[99, 100]

$[3] : NULL

$[1].a：[5, 6]

$[1].a[1]:6

$[1].b：10

$[2][0]：99

2. Vergleichsregeln

Daten in JSON können mit =, <, <=, >, >=, <>, != und <=> verglichen werden. Da die Datentypen in JSON jedoch unterschiedlich sein können, gibt es beim Vergleich unterschiedlicher Typen eine Priorität, wobei高優先級的要大于低優先級的(Sie können den Typ mit der Funktion JSON_TYPE() prüfen). Die Prioritäten von hoch nach niedrig sind wie folgt:

KLECKS
BISSCHEN
UNDURCHSICHTIG
DATETIME
ZEIT
DATUM
BOOLEAN
ANORDNUNG
OBJEKT
Zeichenfolge
INTEGER, DOUBLE
NULL

3. Gemeinsame Funktionen

3.1 Erstellen einer Funktion

3.1.1 JSON_ARRAY

JSON_ARRAY(Wert1, Wert2, Wert3 …)

Generiert ein JSON-Array, das die angegebenen Elemente enthält.

mysql> SELECT JSON_ARRAY(1, "abc", NULL, TRUE, CURTIME());
+---------------------------------------------+
| JSON_ARRAY(1, "abc", NULL, TRUE, CURTIME()) |
+---------------------------------------------+
| [1, "abc", null, wahr, "11:30:24.000000"] |
+---------------------------------------------+

3.1.2 JSON_OBJECT

JSON_OBJECT(Schlüssel1,Wert1,Schlüssel2,Wert2...)

Generiert ein JSON-Objekt, das das angegebene KV-Paar enthält. Wenn ein beliebiger Schlüssel NULL ist oder die Anzahl der Parameter ungerade ist, wird ein Fehler ausgegeben.

mysql> AUSWÄHLEN JSON_OBJECT('id', 87, 'name', 'karotte');
+-----------------------------------------+
| JSON_OBJECT('id', 87, 'Name', 'Karotte') |
+-----------------------------------------+
| {"id": 87, "name": "Karotte"} |
+-----------------------------------------+

3.1.3 JSON_QUOTE

JSON_QUOTE(json_val)

Schließen Sie json_val in " ein.

mysql> AUSWÄHLEN JSON_QUOTE('null'), JSON_QUOTE('"null"');
+--------------------+----------------------+
| JSON_QUOTE('null') | JSON_QUOTE('"null"') |
+--------------------+----------------------+
| "null" | "\"null\"" |
+--------------------+----------------------+
mysql> AUSWÄHLEN JSON_QUOTE('[1, 2, 3]');
+-------------------------+
| JSON_QUOTE('[1, 2, 3]') |
+-------------------------+
| "[1, 2, 3]" |
+-------------------------+

3.1.4 KONVERTIEREN

KONVERTIEREN(json_string,JSON)

mysql> wählen Sie CONVERT('{"mail": "[email protected]", "name": "Amy"}',JSON);
+----------------------------------------------------------+
| KONVERTIEREN('{"mail": "[email protected]", "name": "Amy"}',JSON) |
+----------------------------------------------------------+
| {"mail": "[email protected]", "name": "Amy"} |
+----------------------------------------------------------+

3.2 Abfragefunktion

3.2.1 JSON_CONTAINS

JSON_CONTAINS(json_doc, val[, pfad])

Abfrage, ob das JSON-Dokument die angegebenen Daten im angegebenen Pfad enthält. Wenn ja, wird 1 zurückgegeben, andernfalls 0. Wenn ein beliebiger Parameter NULL ist oder der Pfad nicht existiert, wird NULL zurückgegeben.

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = "1";
mysql> WÄHLEN SIE JSON_CONTAINS(@j, @j2, '$.a');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.a') |
+-------------------------------+
| 1 |
+-------------------------------+
mysql> AUSWÄHLEN JSON_CONTAINS(@j, @j2, '$.b');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.b') |
+-------------------------------+
| 0 |
+-------------------------------+
 
mysql> SET @j2 = '{"d": 4}';
mysql> WÄHLEN SIE JSON_CONTAINS(@j, @j2, '$.a');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.a') |
+-------------------------------+
| 0 |
+-------------------------------+
mysql> AUSWÄHLEN JSON_CONTAINS(@j, @j2, '$.c');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.c') |
+-------------------------------+
| 1 |
+-------------------------------+

3.2.2 JSON_CONTAINS_PATH

JSON_CONTAINS_PATH(json_doc, eins_oder_alle, Pfad[, Pfad] …)

Überprüft, ob der angegebene Pfad existiert. Wenn er existiert, wird 1 zurückgegeben, andernfalls 0. Wenn ein beliebiges Argument NULL ist, wird NULL zurückgegeben.

one_or_all kann nur die Werte "one" oder "all" annehmen. One bedeutet, dass nur einer von beiden vorhanden sein muss; all bedeutet, dass alle vorhanden sein müssen.

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> WÄHLEN SIE JSON_CONTAINS_PATH(@j, 'eins', '$.a', '$.e');
+---------------------------------------------+
| JSON_CONTAINS_PATH(@j, 'eins', '$.a', '$.e') |
+---------------------------------------------+
| 1 |
+---------------------------------------------+
mysql> WÄHLEN SIE JSON_CONTAINS_PATH(@j, 'alle', '$.a', '$.e');
+---------------------------------------------+
| JSON_CONTAINS_PATH(@j, 'alle', '$.a', '$.e') |
+---------------------------------------------+
| 0 |
+---------------------------------------------+
mysql> WÄHLEN SIE JSON_CONTAINS_PATH(@j, 'eins', '$.c.d');
+----------------------------------------+
| JSON_CONTAINS_PATH(@j, 'eins', '$.c.d') |
+----------------------------------------+
| 1 |
+----------------------------------------+
mysql> WÄHLEN SIE JSON_CONTAINS_PATH(@j, 'eins', '$.a.d');
+----------------------------------------+
| JSON_CONTAINS_PATH(@j, 'eins', '$.a.d') |
+----------------------------------------+
| 0 |
+----------------------------------------+

3.2.3 JSON_EXTRACT

JSON_EXTRACT(json_doc, Pfad[, Pfad] ...)

Extrahieren Sie Daten aus einem JSON-Dokument. Wenn ein beliebiger Parameter NULL ist oder der Pfad nicht existiert, wird NULL zurückgegeben. Wenn mehrere Pfade extrahiert werden, werden die zurückgegebenen Daten in ein JSON-Array eingeschlossen.

mysql> AUSWÄHLEN JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]');
+--------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]') |
+--------------------------------------------+
| 20 |
+--------------------------------------------+
mysql> AUSWÄHLEN JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]', '$[0]');
+----------------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]', '$[0]') |
+----------------------------------------------------+
| [20, 10] |
+----------------------------------------------------+
mysql> AUSWÄHLEN JSON_EXTRACT('[10, 20, [30, 40]]', '$[2][*]');
+--------------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[2][*]') |
+--------------------------------------------------+
| [30, 40] |
+--------------------------------------------------+

In MySQL 5.7.9+ können Sie stattdessen "->" verwenden.

mysql> SELECT c, JSON_EXTRACT(c, "$.id"), g
   > VON jemp
   > WO JSON_EXTRACT(c, "$.id") > 1
   > ORDER BY JSON_EXTRACT(c, "$.name");
+-------------------------------+-------------+------+
| c | c->"$.id" | g |
+-------------------------------+-------------+------+
| {"id": "3", "name": "Barney"} | "3" | 3 |
| {"id": "4", "name": "Betty"} | "4" | 4 |
| {"id": "2", "name": "Wilma"} | "2" | 2 |
+-------------------------------+-------------+------+
3 Zeilen im Satz (0,00 Sek.)
 
mysql> SELECT c, c->"$.id", g
   > VON jemp
   > WO c->"$.id" > 1
   > ORDER BY c->"$.name";
+-------------------------------+-------------+------+
| c | c->"$.id" | g |
+-------------------------------+-------------+------+
| {"id": "3", "name": "Barney"} | "3" | 3 |
| {"id": "4", "name": "Betty"} | "4" | 4 |
| {"id": "2", "name": "Wilma"} | "2" | 2 |
+-------------------------------+-------------+------+
3 Zeilen im Satz (0,00 Sek.)

In MySQL 5.7.13+ können Sie auch "->>" verwenden, um das "-Zeichen aus dem extrahierten Ergebnis zu entfernen. Die folgenden drei Effekte sind gleich:

  • JSON_UNQUOTE( JSON_EXTRACT(Spalte, Pfad) )
  • JSON_UNQUOTE(Spalte -> Pfad)
  • Spalte->>Pfad
mysql> AUSWÄHLEN * VON jemp WO g > 2;
+-------------------------------+------+
| c | g |
+-------------------------------+------+
| {"id": "3", "name": "Barney"} | 3 |
| {"id": "4", "name": "Betty"} | 4 |
+-------------------------------+------+
2 Zeilen im Satz (0,01 Sek.)
 
mysql> SELECT c->'$.name' AS name  
  -> VON jemp, WO g > 2;
+----------+
| Name |
+----------+
| "Barney" |
| "Betty" |
+----------+
2 Zeilen im Satz (0,00 Sek.)
 
mysql> SELECT JSON_UNQUOTE(c->'$.name') AS name
  -> VON jemp, WO g > 2;
+--------+
| Name |
+--------+
| Barney |
| Betty |
+--------+
2 Zeilen im Satz (0,00 Sek.)
 
mysql> SELECT c->>'$.name' AS name
  -> VON jemp, WO g > 2;
+--------+
| Name |
+--------+
| Barney |
| Betty |
+--------+
2 Zeilen im Satz (0,00 Sek.)

3.2.4 JSON_KEYS

JSON_KEYS(json_doc[, Pfad])

Holen Sie sich alle Schlüsselwerte des JSON-Dokuments unter dem angegebenen Pfad und geben Sie ein JSON-Array zurück. Wenn ein beliebiger Parameter NULL ist oder der Pfad nicht existiert, wird NULL zurückgegeben.

mysql> JSON_KEYS AUSWÄHLEN('{"a": 1, "b": {"c": 30}}');
+------------------------------------------+
| JSON_KEYS('{"a": 1, "b": {"c": 30}}') |
+------------------------------------------+
| ["ein", "ein"] |
+------------------------------------------+
mysql> AUSWÄHLEN JSON_KEYS('{"a": 1, "b": {"c": 30}}', '$.b');
+-------------------------------------------------+
| JSON_KEYS('{"a": 1, "b": {"c": 30}}', '$.b') |
+-------------------------------------------------+
| ["c"] |
+-------------------------------------------------+

3.2.5 JSON_SEARCH

JSON_SEARCH(json_doc, eins_oder_alles, Suchzeichen[, Escapezeichen[, Pfad] ...])

Abfragepfade, die die angegebene Zeichenfolge enthalten, und Rückgabe als JSON-Array. Wenn ein Argument NUL ist oder der Pfad nicht existiert, wird NULL zurückgegeben.

  • one_or_all: „one“ bedeutet, dass alle Ergebnisse zurückgegeben werden, wenn eines gefunden wird; „all“ bedeutet, dass alle Ergebnisse zurückgegeben werden.
  • search_str: Die zu suchende Zeichenfolge. Sie können zum Abgleichen „%“ oder „_“ in LIKE verwenden.
  • Pfad: Suche unter dem angegebenen Pfad.
mysql> SET @j = '["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]';
 
mysql> WÄHLEN SIE JSON_SEARCH(@j, 'eins', 'abc');
+-------------------------------+
| JSON_SEARCH(@j, 'eins', 'abc') |
+-------------------------------+
| "$[0]" |
+-------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', 'abc');
+-------------------------------+
| JSON_SEARCH(@j, 'alle', 'abc') |
+-------------------------------+
| ["$[0]", "$[2].x"] |
+-------------------------------+
 
mysql> SELECT JSON_SEARCH(@j, 'alle', 'ghi');
+-------------------------------+
| JSON_SEARCH(@j, 'alle', 'ghi') |
+-------------------------------+
| NULL |
+-------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '10');
+------------------------------+
| JSON_SEARCH(@j, 'alle', '10') |
+------------------------------+
| "$[1][0].k" |
+------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '10', NULL, '$');
+-----------------------------------------+
| JSON_SEARCH(@j, 'alle', '10', NULL, '$') |
+-----------------------------------------+
| "$[1][0].k" |
+-----------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '10', NULL, '$[*]');
+--------------------------------------------+
| JSON_SEARCH(@j, 'alle', '10', NULL, '$[*]') |
+--------------------------------------------+
| "$[1][0].k" |
+--------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '10', NULL, '$**.k');
+---------------------------------------------+
| JSON_SEARCH(@j, 'alle', '10', NULL, '$**.k') |
+---------------------------------------------+
| "$[1][0].k" |
+---------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '10', NULL, '$[*][0].k');
+-------------------------------------------------+
| JSON_SEARCH(@j, 'alle', '10', NULL, '$[*][0].k') |
+-------------------------------------------------+
| "$[1][0].k" |
+-------------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '10', NULL, '$[1]');
+--------------------------------------------+
| JSON_SEARCH(@j, 'alle', '10', NULL, '$[1]') |
+--------------------------------------------+
| "$[1][0].k" |
+--------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '10', NULL, '$[1][0]');
+--------------------------------------------------+
| JSON_SEARCH(@j, 'alle', '10', NULL, '$[1][0]') |
+--------------------------------------------------+
| "$[1][0].k" |
+--------------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', 'abc', NULL, '$[2]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'alle', 'abc', NULL, '$[2]') |
+---------------------------------------------+
| "$[2].x" |
+---------------------------------------------+
 
mysql> WÄHLEN SIE JSON_SEARCH(@j, 'alle', '%a%');
+-------------------------------+
| JSON_SEARCH(@j, 'alle', '%a%') |
+-------------------------------+
| ["$[0]", "$[2].x"] |
+-------------------------------+
 
mysql> WÄHLEN SIE JSON_SEARCH(@j, 'alle', '%b%');
+-------------------------------+
| JSON_SEARCH(@j, 'alle', '%b%') |
+-------------------------------+
| ["$[0]", "$[2].x", "$[3].y"] |
+-------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '%b%', NULL, '$[0]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'alle', '%b%', NULL, '$[0]') |
+---------------------------------------------+
| "$[0]" |
+---------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '%b%', NULL, '$[2]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'alle', '%b%', NULL, '$[2]') |
+---------------------------------------------+
| "$[2].x" |
+---------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '%b%', NULL, '$[1]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'alle', '%b%', NULL, '$[1]') |
+---------------------------------------------+
| NULL |
+---------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '%b%', '', '$[1]');
+----------------------------------------------+
| JSON_SEARCH(@j, 'alle', '%b%', '', '$[1]') |
+----------------------------------------------+
| NULL |
+----------------------------------------------+
 
mysql> AUSWÄHLEN JSON_SEARCH(@j, 'alle', '%b%', '', '$[3]');
+----------------------------------------------+
| JSON_SEARCH(@j, 'alle', '%b%', '', '$[3]') |
+----------------------------------------------+
| "$[3].y" |
+----------------------------------------------+

3.3 Funktionen ändern

3.3.1 JSON_APPEND/JSON_ARRAY_APPEND

JSON_ARRAY_APPEND(json_doc, Pfad, Wert[, Pfad, Wert] …)

Hängt val am Ende des JSON-Arrays am angegebenen Pfad an. Wenn der angegebene Pfad ein JSON-Objekt ist, wird es in ein JSON-Array gekapselt und dann angehängt. Wenn ein beliebiges Argument NULL ist, wird NULL zurückgegeben.

mysql> SET @j = '["a", ["b", "c"], "d"]';
mysql> AUSWÄHLEN JSON_ARRAY_APPEND(@j, '$[1]', 1);
+----------------------------------+
| JSON_ARRAY_APPEND(@j, '$[1]', 1) |
+----------------------------------+
| ["ein", ["b", "c", 1], "d"] |
+----------------------------------+
mysql> AUSWÄHLEN JSON_ARRAY_APPEND(@j, '$[0]', 2);
+----------------------------------+
| JSON_ARRAY_APPEND(@j, '$[0]', 2) |
+----------------------------------+
| [["ein", 2], ["b", "c"], "d"] |
+----------------------------------+
mysql> AUSWÄHLEN JSON_ARRAY_APPEND(@j, '$[1][0]', 3);
+-------------------------------------+
| JSON_ARRAY_APPEND(@j, '$[1][0]', 3) |
+-------------------------------------+
| ["ein", [["b", 3], "c"], "d"] |
+-------------------------------------+
 
mysql> SET @j = '{"a": 1, "b": [2, 3], "c": 4}';
mysql> AUSWÄHLEN JSON_ARRAY_APPEND(@j, '$.b', 'x');
+------------------------------------+
| JSON_ARRAY_APPEND(@j, '$.b', 'x') |
+------------------------------------+
| {"a": 1, "b": [2, 3, "x"], "c": 4} |
+------------------------------------+
mysql> AUSWÄHLEN JSON_ARRAY_APPEND(@j, '$.c', 'y');
+--------------------------------------+
| JSON_ARRAY_APPEND(@j, '$.c', 'y') |
+--------------------------------------+
| {"a": 1, "b": [2, 3], "c": [4, "y"]} |
+--------------------------------------+
 
mysql> SET @j = '{"a": 1}';
mysql> AUSWÄHLEN JSON_ARRAY_APPEND(@j, '$', 'z');
+---------------------------------+
| JSON_ARRAY_APPEND(@j, '$', 'z') |
+---------------------------------+
| [{"a": 1}, "z"] |
+---------------------------------+

3.3.2 JSON_ARRAY_INSERT

JSON_ARRAY_INSERT(json_doc, Pfad, Wert[, Pfad, Wert] …)

Fügen Sie val in das durch den Pfad angegebene JSON-Array-Element ein und verschieben Sie die ursprüngliche Position und die Elemente nacheinander nach rechts. Wenn die durch den Pfad angegebenen Daten kein JSON-Array-Element sind, wird dieser Wert übersprungen; wenn der angegebene Elementindex die Länge des JSON-Arrays überschreitet, wird er am Ende eingefügt.

mysql> SET @j = '["a", {"b": [1, 2]}, [3, 4]]';
mysql> AUSWÄHLEN JSON_ARRAY_INSERT(@j, '$[1]', 'x');
+------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[1]', 'x') |
+------------------------------------+
| ["a", "x", {"b": [1, 2]}, [3, 4]] |
+------------------------------------+
mysql> AUSWÄHLEN JSON_ARRAY_INSERT(@j, '$[100]', 'x');
+--------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[100]', 'x') |
+--------------------------------------+
| ["a", {"b": [1, 2]}, [3, 4], "x"] |
+--------------------------------------+
mysql> AUSWÄHLEN JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x');
+-----------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x') |
+-----------------------------------------+
| ["ein", {"b": ["x", 1, 2]}, [3, 4]] |
+-----------------------------------------+
mysql> AUSWÄHLEN JSON_ARRAY_INSERT(@j, '$[2][1]', 'y');
+------------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[2][1]', 'y') |
+------------------------------------------+
| ["ein", {"b": [1, 2]}, [3, "j", 4]] |
+------------------------------------------+
mysql> AUSWÄHLEN JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y');
+----------------------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y') |
+----------------------------------------------------+
| ["x", "a", {"b": [1, 2]}, [3, 4]] |
+----------------------------------------------------+

3.3.3 JSON_INSERT/JSON_REPLACE/JSON_SET

JSON_INSERT(json_doc, Pfad, Wert[, Pfad, Wert] …)

Fügt Daten unter dem angegebenen Pfad ein. Wenn der Pfad bereits existiert, wird dieser Wert ignoriert (er wird nur eingefügt, wenn er nicht existiert).

mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[wahr, falsch]');
+----------------------------------------------------+
| JSON_INSERT(@j, '$.a', 10, '$.c', '[wahr, falsch]') |
+----------------------------------------------------+
| {"a": 1, "b": [2, 3], "c": "[wahr, falsch]"} |
+----------------------------------------------------+

JSON_REPLACE(json_doc, Pfad, Wert[, Pfad, Wert] …)

Ersetzt die Daten im angegebenen Pfad. Wenn ein Pfad nicht existiert, wird er übersprungen (ersetzen Sie ihn nur, wenn er existiert). Wenn ein beliebiges Argument NULL ist, wird NULL zurückgegeben.

mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[wahr, falsch]');
+-----------------------------------------------------+
| JSON_REPLACE(@j, '$.a', 10, '$.c', '[wahr, falsch]') |
+-----------------------------------------------------+
| {"a": 10, "b": [2, 3]} |
+-----------------------------------------------------+

JSON_SET(json_doc, Pfad, Wert[, Pfad, Wert] …)

Legt die Daten für den angegebenen Pfad fest (unabhängig davon, ob dieser existiert oder nicht). Wenn ein beliebiges Argument NULL ist, wird NULL zurückgegeben.

mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_SET(@j, '$.a', 10, '$.c', '[wahr, falsch]');
+-------------------------------------------------+
| JSON_SET(@j, '$.a', 10, '$.c', '[wahr, falsch]') |
+-------------------------------------------------+
| {"a": 10, "b": [2, 3], "c": "[wahr, falsch]"} |
+-------------------------------------------------+
mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[wahr, falsch]');
+----------------------------------------------------+
| JSON_INSERT(@j, '$.a', 10, '$.c', '[wahr, falsch]') |
+----------------------------------------------------+
| {"a": 1, "b": [2, 3], "c": "[wahr, falsch]"} |
+----------------------------------------------------+
mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[wahr, falsch]');
+-----------------------------------------------------+
| JSON_REPLACE(@j, '$.a', 10, '$.c', '[wahr, falsch]') |
+-----------------------------------------------------+
| {"a": 10, "b": [2, 3]} |
+-----------------------------------------------------+

3.3.4 JSON_MERGE

JSON_MERGE(json_doc, json_doc[, json_doc] …)

Mehrere JSON-Dokumente zusammenführen. Die Regeln lauten wie folgt:

  • Wenn es sich bei allen um JSON-Arrays handelt, werden die Ergebnisse automatisch in einem JSON-Array zusammengeführt.
  • Wenn es sich bei allen um JSON-Objekte handelt, werden die Ergebnisse automatisch zu einem JSON-Objekt zusammengeführt.
  • Wenn mehrere Typen vorhanden sind, kapseln Sie die Nicht-JSON-Array-Elemente in ein JSON-Array und führen Sie dann eine Zusammenführung gemäß Regel 1 durch.
mysql> SELECT JSON_MERGE('[1, 2]', '[wahr, falsch]');
+------------------------------------------+
| JSON_MERGE('[1, 2]', '[wahr, falsch]') |
+------------------------------------------+
| [1, 2, wahr, falsch] |
+------------------------------------------+
mysql> AUSWÄHLEN JSON_MERGE('{"name": "x"}', '{"id": 47}');
+----------------------------------------------+
| JSON_MERGE('{"name": "x"}', '{"id": 47}') |
+----------------------------------------------+
| {"id": 47, "name": "x"} |
+----------------------------------------------+
mysql> SELECT JSON_MERGE('1', 'wahr');
+-------------------------+
| JSON_MERGE('1', 'wahr') |
+-------------------------+
| [1, wahr] |
+-------------------------+
mysql> AUSWÄHLEN JSON_MERGE('[1, 2]', '{"id": 47}');
+------------------------------------+
| JSON_MERGE('[1, 2]', '{"id": 47}') |
+------------------------------------+
| [1, 2, {"id": 47}] |
+------------------------------------+

3.3.5 JSON_REMOVE

JSON_REMOVE(json_doc, Pfad[, Pfad] ...)

Entfernt die Daten des angegebenen Pfades. Wenn ein Pfad nicht existiert, wird er übersprungen. Wenn ein beliebiges Argument NULL ist, wird NULL zurückgegeben.

mysql> SET @j = '["a", ["b", "c"], "d"]';
mysql> AUSWÄHLEN JSON_REMOVE(@j, '$[1]');
+-------------------------+
| JSON_REMOVE(@j, '$[1]') |
+-------------------------+
| ["ein", "ein"] |
+-------------------------+

3.3.6 JSON_UNQUOTE

JSON_UNQUOTE(Wert)

Entfernen Sie die Anführungszeichen um val. Wenn val NULL ist, wird NULL zurückgegeben.

mysql> SET @j = '"abc"';
mysql> AUSWÄHLEN @j, JSON_UNQUOTE(@j);
+----------+------------------+
| @j | JSON_UNQUOTE(@j) |
+----------+------------------+
| "abc" | abc |
+----------+------------------+
mysql> SET @j = '[1, 2, 3]';
mysql> AUSWÄHLEN @j, JSON_UNQUOTE(@j);
+--------------+------------------+
| @j | JSON_UNQUOTE(@j) |
+--------------+------------------+
| [1, 2, 3] | [1, 2, 3] |
+--------------+------------------+

3.4 JSON-Feature-Abfrage

3.4.1 JSON_DEEPTH

JSON_DEPTH(json_doc)

Holen Sie sich die Tiefe eines JSON-Dokuments. Wenn das Argument NULL ist, wird NULL zurückgegeben.

Ein leeres JSON-Array, JSON-Objekt oder Skalar hat eine Tiefe von 1.

mysql> AUSWÄHLEN JSON_DEPTH('{}'), JSON_DEPTH('[]'), JSON_DEPTH('true');
+------------------+------------------+--------------------+
| JSON_DEPTH('{}') | JSON_DEPTH('[]') | JSON_DEPTH('true') |
+------------------+------------------+--------------------+
| 1 | 1 | 1 |
+------------------+------------------+--------------------+
mysql> AUSWÄHLEN JSON_DEPTH('[10, 20]'), JSON_DEPTH('[[], {}]');
+------------------------+------------------------+
| JSON_DEPTH('[10, 20]') | JSON_DEPTH('[[], {}]') |
+------------------------+------------------------+
| 2 | 2 |
+------------------------+------------------------+
mysql> AUSWÄHLEN JSON_DEPTH('[10, {"a": 20}]');
+-------------------------------+
| JSON_DEPTH('[10, {"a": 20}]') |
+-------------------------------+
| 3 |
+-------------------------------+

3.4.2 JSON_LENGTH

JSON_LENGTH(json_doc[, Pfad])

Ruft die Länge des angegebenen Pfads ab. Wenn das Argument NULL ist, wird NULL zurückgegeben.

Regeln zur Längenberechnung:

  • Die Länge eines Skalars beträgt 1;
  • Die Länge des JSON-Arrays entspricht der Anzahl der Elemente.
  • Die Länge des JSON-Objekts entspricht der Anzahl der Schlüssel.
mysql> WÄHLEN SIE JSON_LENGTH('[1, 2, {"a": 3}]');
+---------------------------------+
| JSON_LENGTH('[1, 2, {"a": 3}]') |
+---------------------------------+
| 3 |
+---------------------------------+
mysql> JSON_LENGTH AUSWÄHLEN('{"a": 1, "b": {"c": 30}}');
+-----------------------------------------+
| JSON_LENGTH('{"a": 1, "b": {"c": 30}}') |
+-----------------------------------------+
| 2 |
+-----------------------------------------+
mysql> AUSWÄHLEN JSON_LENGTH('{"a": 1, "b": {"c": 30}}', '$.b');
+------------------------------------------------+
| JSON_LENGTH('{"a": 1, "b": {"c": 30}}', '$.b') |
+------------------------------------------------+
| 1 |
+------------------------------------------------+

3.4.3 JSON_TYPE

JSON_TYPE(json_wert)

Holen Sie sich den spezifischen Typ des JSON-Dokuments. Wenn das Argument NULL ist, wird NULL zurückgegeben.

3.4.4 JSON_VALID

JSON_VALID(Wert)

Bestimmen Sie, ob der Wert in einem gültigen JSON-Format vorliegt. Wenn er 1 ist, ist er andernfalls 0. Wenn das Argument NUL ist, wird NULL zurückgegeben.

mysql> AUSWÄHLEN JSON_VALID('{"a": 1}');
+------------------------+
| JSON_VALID('{"a": 1}') |
+------------------------+
| 1 |
+------------------------+
mysql> SELECT JSON_VALID('hallo'), JSON_VALID('"hallo"');
+---------------------+-------------------------+
| JSON_VALID('hallo') | JSON_VALID('"hallo"') |
+---------------------+-------------------------+
| 0 | 1 |
+---------------------+-------------------------+

Dies ist das Ende dieses Artikels über die Verwendung allgemeiner MySQL JSON-Funktionen. Weitere verwandte allgemeine MySQL JSON-Funktionen finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!

Das könnte Sie auch interessieren:
  • So ordnen Sie die Felder in MySQL in der Mybatis Plus-Entity-Klasse dem JSON-Format zu
  • MySQL extrahiert interne JSON-Felder und gibt sie als Zahlen aus.
  • Beispielcode zum Konvertieren des Mysql-Abfrageergebnissatzes in JSON-Daten
  • Detaillierte Erklärung zur Abfrage von Feldern im JSON-Format in MySQL
  • Datenabfragevorgang im MySQL-JSON-Format
  • MySQL 8.0 kann jetzt JSON verarbeiten

<<:  WML-Tag-Zusammenfassung

>>:  Beispielcode zur Implementierung eines 3D-Text-Hover-Effekts mit CSS3

Artikel empfehlen

Mysql implementiert drei Funktionen zum Feldspleißen

Beim Exportieren von Daten in Operationen ist das...

CSS: besuchte geheime Erinnerungen des Pseudoklassenselektors

Gestern wollte ich a:visited verwenden, um die Fa...

Grafisches Tutorial zur Installation und Konfiguration von MySQL 8.0.12 (Windows-Version)

1. Einleitung Im Projekt wird MySQL verwendet. Ic...

Ein tiefes Verständnis der spitzen Klammern in Bash (für Anfänger)

Vorwort Bash verfügt über viele wichtige integrie...

Tutorial zur Installation und Konfiguration von MySQL für die kostenlose Installationsversion von Win10

Ich habe viel online gesucht und festgestellt, da...

CSS Lieferadresse Parallelogramm Linienstil Beispielcode

Der Code sieht folgendermaßen aus: // Linienstil ...

Bereitstellung eines MySQL-Hochverfügbarkeitsclusters und Implementierung eines Failovers

Inhaltsverzeichnis 1. MHA 1. Konzept 2. Zusammens...

Detaillierte Erklärung der benutzerdefinierten Ereignisse von Vue-Komponenten

Inhaltsverzeichnis Zusammenfassen <Vorlage>...

Docker trifft auf Intellij IDEA, Java-Entwicklung steigert die Produktivität um das Zehnfache

Inhaltsverzeichnis 1. Vorbereitung vor der Entwic...

Mehrere Szenarien für die Verwendung des Nginx Rewrite-Moduls

Anwendungsszenario 1: Domänennamenbasierte Umleit...

JavaScript zum Implementieren des Click-to-Switch-Bestätigungscodes und der Bestätigung

In diesem Artikel wird der spezifische JavaScript...

Syntax und Beispielanalyse der JavaScript-Array-Methode „reduce()“

Vorwort Die Methode „reduce()“ erhält eine Funkti...

Vue kapselt die öffentliche Funktionsmethode zum Exportieren von Excel-Daten

vue+element UI kapselt eine öffentliche Funktion ...

Detaillierte Erklärung der langsamen Remote-Verbindung von Navicat zu MySQL

Die endgültige Lösung ist im letzten Bild Wenn Si...

Der beste Weg, ein JAR-Paketprojekt unter einem Centos7-Server zu starten

Vorwort Jeder weiß, wie man ein JAR-Paket unter L...