Umgang mit JSON-Daten in MySQL

MySQLBeginner
Jetzt üben

Einführung

In diesem Lab lernen Sie, wie Sie den JSON-Datentyp in MySQL effektiv nutzen. Sie führen grundlegende Operationen durch, wie das Einfügen von JSON-Dokumenten, das Abfragen spezifischer Felder mit Funktionen wie JSON_EXTRACT und dem ->> Operator, das Modifizieren von Daten innerhalb einer JSON-Spalte und das Optimieren von Abfragen durch das Erstellen eines Indexes auf einer JSON-Eigenschaft.

Während dieses Labs verbinden Sie sich mit einem MySQL-Server, erstellen eine dedizierte Datenbank und Tabelle und führen dann eine Reihe von praktischen Aufgaben durch, um Ihre Fähigkeiten im Umgang mit JSON-Daten im Kontext einer relationalen Datenbank aufzubauen.

Mit MySQL verbinden und die Datenbank erstellen

In diesem ersten Schritt verbinden Sie sich mit dem MySQL-Server und richten die für das Lab erforderliche Datenbank und Tabelle ein.

Öffnen Sie zunächst das Terminal auf Ihrem Desktop.

Verbinden Sie sich mit dem MySQL-Server mit root-Benutzerrechten. In dieser Lab-Umgebung ermöglicht Ihnen sudo die Verbindung ohne Passwort.

sudo mysql -u root

Nach der Verbindung ändert sich die Eingabeaufforderung zu mysql>, was anzeigt, dass Sie sich in der MySQL-Shell befinden.

Erstellen Sie als Nächstes eine neue Datenbank namens jsondb. Die Klausel IF NOT EXISTS stellt sicher, dass der Befehl ohne Fehler ausgeführt wird, falls die Datenbank bereits existiert.

CREATE DATABASE IF NOT EXISTS jsondb;

Wechseln Sie nun zu Ihrer neu erstellten Datenbank, um sie zur aktiven Datenbank für nachfolgende Befehle zu machen.

USE jsondb;

Erstellen Sie schließlich eine Tabelle namens products. Diese Tabelle wird eine Spalte mit dem Datentyp JSON enthalten, um detaillierte Produktinformationen zu speichern.

CREATE TABLE IF NOT EXISTS products (
    id INT AUTO_INCREMENT PRIMARY KEY,
    product_name VARCHAR(255),
    product_details JSON
);

Diese Anweisung definiert eine Tabelle mit drei Spalten:

  • id: Eine eindeutige, automatisch inkrementierende Ganzzahl für jeden Datensatz.
  • product_name: Eine Zeichenkette für den Namen des Produkts.
  • product_details: Eine JSON-Spalte zur Speicherung strukturierter Daten.

Sie haben die notwendige Datenbank und Tabelle erfolgreich eingerichtet. Lassen Sie die MySQL-Shell für den nächsten Schritt geöffnet.

JSON-Daten einfügen und abfragen

Nachdem die Tabelle erstellt wurde, fügen Sie nun einen Datensatz mit einem JSON-Dokument ein und führen dann eine grundlegende Abfrage durch, um ihn abzurufen.

Führen Sie in derselben MySQL-Shell die folgende INSERT-Anweisung aus, um ein neues Produkt hinzuzufügen.

INSERT INTO products (product_name, product_details) VALUES (
    'Laptop',
    '{
        "brand": "Dell",
        "model": "XPS 13",
        "specs": {
            "processor": "Intel Core i7",
            "memory": "16GB",
            "storage": "512GB SSD"
        },
        "price": 1200
    }'
);

Dieser Befehl fügt einen 'Laptop'-Datensatz ein. Die Spalte product_details wird mit einem JSON-Objekt gefüllt, das verschachtelte Daten wie specs enthält.

Um zu bestätigen, dass die Daten korrekt eingefügt wurden, fragen Sie die Tabelle products ab, um deren Inhalt anzuzeigen.

SELECT * FROM products;

Die Ausgabe sollte die gerade eingefügte Zeile anzeigen. Beachten Sie, wie die JSON-Daten in der Spalte product_details gespeichert sind.

+----+--------------+--------------------------------------------------------------------------------------------------------------------------------+
| id | product_name | product_details                                                                                                                |
+----+--------------+--------------------------------------------------------------------------------------------------------------------------------+
|  1 | Laptop       | {"brand": "Dell", "model": "XPS 13", "price": 1200, "specs": {"memory": "16GB", "storage": "512GB SSD", "processor": "Intel Core i7"}} |
+----+--------------+--------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

Sie haben erfolgreich einen Datensatz mit JSON-Daten eingefügt. Im nächsten Schritt lernen Sie, wie Sie spezifische Informationen aus diesem JSON-Objekt extrahieren.

Daten aus JSON-Feldern extrahieren

Das Speichern von Daten in JSON ist nützlich, aber Sie müssen auch in der Lage sein, einzelne Felder darin abzufragen. In diesem Schritt verwenden Sie die Funktion JSON_EXTRACT und JSON_UNQUOTE, um spezifische Werte aus der Spalte product_details abzurufen.

Die Funktion JSON_EXTRACT ermöglicht es Ihnen, einen Wert aus einem JSON-Dokument mithilfe eines Pfadausdrucks auszuwählen. Der Pfad beginnt mit $ zur Darstellung des Dokumenten-Roots.

Lassen Sie uns die Marke (brand) des Laptops extrahieren.

SELECT JSON_EXTRACT(product_details, '$.brand') AS brand FROM products WHERE product_name = 'Laptop';

Diese Abfrage gibt die Marke zurück, aber beachten Sie, dass das Ergebnis ein JSON-String ist, der Anführungszeichen enthält.

+--------+
| brand  |
+--------+
| "Dell" |
+--------+
1 row in set (0.00 sec)

Für ein saubereres Ergebnis können Sie JSON_UNQUOTE in Kombination mit JSON_EXTRACT verwenden. Diese Kombination extrahiert den Wert und entfernt die Anführungszeichen, wodurch ein Standard-String zurückgegeben wird.

SELECT JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.brand')) AS brand FROM products WHERE product_name = 'Laptop';

Die Ausgabe ist nun der reine Text Dell.

+-------+
| brand |
+-------+
| Dell  |
+-------+
1 row in set (0.00 sec)

Sie können Pfadausdrücke auch verwenden, um auf Werte in verschachtelten Objekten zuzugreifen. Um den Prozessor (processor) aus dem Objekt specs zu erhalten, verwenden Sie den Pfad $.specs.processor.

SELECT JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.specs.processor')) AS processor FROM products WHERE product_name = 'Laptop';

Dies extrahiert den verschachtelten Wert korrekt.

+-----------------+
| processor       |
+-----------------+
| Intel Core i7   |
+-----------------+
1 row in set (0.00 sec)

Diese Funktionen sind auch in WHERE-Klauseln zum Filtern von Zeilen nützlich. Um alle Produkte mit einem Preis über 1000 zu finden, müssen Sie den extrahierten JSON-Wert für den Vergleich in einen numerischen Typ CASTen.

SELECT product_name, JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS price FROM products WHERE CAST(JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS SIGNED) > 1000;

Diese Abfrage zeigt, wie Datensätze basierend auf einem numerischen Wert innerhalb eines JSON-Feldes gefiltert werden.

+--------------+-------+
| product_name | price |
+--------------+-------+
| Laptop       | 1200  |
+--------------+-------+
1 row in set (0.00 sec)

Sie wissen nun, wie Sie Daten basierend auf JSON-Feldern extrahieren und filtern.

JSON-Felder aktualisieren und hinzufügen

Daten ändern sich im Laufe der Zeit, und Sie benötigen eine Möglichkeit, in Ihrer Datenbank gespeicherte JSON-Dokumente zu ändern. In diesem Schritt verwenden Sie die Funktion JSON_SET, um vorhandene Werte zu aktualisieren und neue Schlüssel-Wert-Paare hinzuzufügen.

Die Funktion JSON_SET modifiziert ein JSON-Dokument, indem sie die Zielspalte, einen Pfad zum Feld und den neuen Wert als Argumente nimmt.

Zuerst aktualisieren wir den Preis (price) des Laptops von 1200 auf 1250.

UPDATE products
SET product_details = JSON_SET(product_details, '$.price', 1250)
WHERE product_name = 'Laptop';

Um die Änderung zu überprüfen, fragen Sie den Preis erneut ab.

SELECT JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS price FROM products WHERE product_name = 'Laptop';

Die Ausgabe sollte nun den neuen Preis anzeigen.

+-------+
| price |
+-------+
| 1250  |
+-------+
1 row in set (0.00 sec)

Wenn der angegebene Pfad nicht existiert, fügt JSON_SET den neuen Schlüssel und Wert hinzu. Fügen wir dem Produkt eine color-Eigenschaft hinzu.

UPDATE products
SET product_details = JSON_SET(product_details, '$.color', 'Silver')
WHERE product_name = 'Laptop';

Fragen Sie nun das gesamte JSON-Objekt ab, um das neu hinzugefügte Feld anzuzeigen.

SELECT product_details FROM products WHERE product_name = 'Laptop';

Die Ausgabe zeigt das Dokument product_details, das nun die color-Eigenschaft enthält.

+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| product_details                                                                                                                                     |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| {"brand": "Dell", "color": "Silver", "model": "XPS 13", "price": 1250, "specs": {"memory": "16GB", "storage": "512GB SSD", "processor": "Intel Core i7"}} |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

Sie haben erfolgreich ein JSON-Dokument innerhalb einer Tabelle geändert und erweitert.

Index auf JSON-Eigenschaft erstellen

Bei großen Tabellen kann die Abfrage von JSON-Feldern langsam sein. Um die Leistung zu verbessern, können Sie einen Index auf einen Wert erstellen, der aus einer JSON-Spalte extrahiert wird. In MariaDB wird dies erreicht, indem zuerst eine virtuelle Spalte basierend auf dem JSON-Feld hinzugefügt und dann ein Index auf dieser virtuellen Spalte erstellt wird.

In diesem Schritt erstellen Sie eine virtuelle Spalte für die price-Eigenschaft und indizieren diese, um preisbasierte Abfragen zu beschleunigen.

Fügen Sie zuerst eine virtuelle Spalte hinzu, die den Preis aus den JSON-Daten extrahiert:

ALTER TABLE products ADD COLUMN price_virtual INT AS (CAST(JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS SIGNED)) STORED;

Dieser Befehl fügt eine virtuelle Spalte namens price_virtual hinzu, die den Preiswert aus den JSON-Daten automatisch berechnet und speichert.

Erstellen Sie nun einen Index auf dieser virtuellen Spalte:

CREATE INDEX idx_product_price ON products (price_virtual);

Dieser Ansatz ermöglicht es MariaDB, Zeilen basierend auf dem numerischen Preis effizient über die indizierte virtuelle Spalte nachzuschlagen.

Um zu bestätigen, dass der Index erstellt wurde, verwenden Sie den Befehl SHOW INDEXES.

SHOW INDEXES FROM products;

Die Ausgabe listet alle Indizes der Tabelle products auf, einschließlich Ihres neuen idx_product_price.

+----------+------------+-------------------+...
| Table    | Non_unique | Key_name          |...
+----------+------------+-------------------+...
| products |          0 | PRIMARY           |...
| products |          1 | idx_product_price |...
+----------+------------+-------------------+...

Der wichtigste Teil ist zu sehen, ob der Optimizer den Index verwendet. Sie können dies mit dem Befehl EXPLAIN überprüfen.

EXPLAIN SELECT product_name FROM products WHERE price_virtual > 1200;

Suchen Sie in der EXPLAIN-Ausgabe in den Spalten possible_keys und key. Sie sollten idx_product_price dort aufgeführt sehen, was bestätigt, dass MariaDB Ihren Index verwendet, um die Abfrage effizient auszuführen.

Sie können auch mit dem ursprünglichen JSON-Ausdruck abfragen, und MariaDBs Optimizer sollte immer noch in der Lage sein, den Index auf der virtuellen Spalte zu verwenden:

EXPLAIN SELECT product_name FROM products WHERE CAST(JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS SIGNED) > 1200;

Sie haben erfolgreich eine virtuelle Spalte erstellt und diese indiziert, um Abfragen von JSON-Eigenschaften zu optimieren.

Sie können die MySQL-Shell nun verlassen.

exit

Zusammenfassung

In diesem Lab haben Sie praktische Erfahrungen mit der Verarbeitung von JSON-Daten in MariaDB gesammelt. Sie haben den gesamten Workflow kennengelernt, von der Einrichtung der Datenbankstruktur bis hin zur Durchführung fortgeschrittener Operationen.

Sie haben erfolgreich strukturierte JSON-Daten eingefügt, spezifische Felder mit JSON_EXTRACT und JSON_UNQUOTE abgefragt und Datensätze basierend auf Werten innerhalb des JSON-Dokuments gefiltert. Sie haben auch das Ändern dieser Daten mit JSON_SET geübt, um vorhandene Eigenschaften zu aktualisieren und neue hinzuzufügen. Schließlich haben Sie eine wichtige Optimierungstechnik gelernt, indem Sie eine virtuelle Spalte für eine JSON-Eigenschaft erstellt und diese indiziert haben, um die Abfrageleistung zu verbessern.

Diese Fähigkeiten sind wertvoll für das Design flexibler Datenbankschemata und die effiziente Verwaltung von semi-strukturierten Daten in MariaDB.