MariaDB JSON_SEARCH() erklärt

In MariaDB, JSON_SEARCH() ist eine integrierte Funktion, mit der Sie den Pfad zu einem bestimmten Wert in einem JSON-Dokument abrufen können.

Es akzeptiert das JSON-Dokument und eine Zeichenfolge als Argumente und gibt den Pfad zu der angegebenen Zeichenfolge innerhalb des Dokuments zurück.

Syntax

Die Syntax sieht so aus:

JSON_SEARCH(
    json_doc, 
    return_arg, 
    search_str[, escape_char[, path] ...]
    )

Wo:

json_doc ist das JSON-Dokument und search_str ist die Zeichenfolge.
return_arg ist das Schlüsselwort one oder all . Wenn Sie one verwenden , wird nur der erste Pfad zurückgegeben. Alle anderen Vorkommnisse werden ignoriert. Welcher Pfad als „erster“ betrachtet wird, ist undefiniert (laut MariaDB-Dokumentation). Wenn all angegeben ist, werden die Pfade aller Vorkommen zurückgegeben. Wenn mehrere Pfade vorhanden sind, werden sie automatisch als Array umbrochen.
Das escape_char argument ist ein optionales Zeichen, das als Escape-Zeichen verwendet werden kann.
Der path Argument ist ein optionales Argument, um zu bestimmen, wo der „Top-Level“-Pfad innerhalb des JSON-Dokuments beginnt.

Beispiel

Hier ist ein Beispiel zur Veranschaulichung:

SET @json = '
    { 
        "name" : "Wag", 
        "type" : "Dog" 
    }';

SELECT JSON_SEARCH(@json, 'one', 'Wag');

Ergebnis:

+----------------------------------------------+| JSON_SEARCH(@json, 'one', 'Wag') |+-----------------------------------------------+ | "$.name" |+---------------------------------+

Hier ist ein Beispiel für die Rückgabe des Pfads für ein Element in einem Array:

SET @json = '
    { 
        "product" : "Left Handed Screwdriver", 
        "sizes" : [ "Small", "Medium", "Large" ],
    }';

SELECT JSON_SEARCH(@json, 'one', 'Medium');

Ergebnis:

+-------------------------------------+| JSON_SEARCH(@json, 'one', "Medium") |+----------------------------------- --+| "$.Größen[1]" |+------------------------------------+ 
 Arrays sind nullbasiert, also $.sizes[1] bezieht sich auf das zweite Element im Array.
 Mehrere Vorkommen
 
 Wenn Sie alle Pfade zurückgeben möchten, die die Zeichenfolge enthalten, verwenden Sie all statt one für das zweite Argument.
 SET @json = '[
    { "name": "Wag", "type": "Dog", "weight": 20 },
    { "name": "Bark", "type": "Dog", "weight": 10 },
    { "name": "Meow", "type": "Cat", "weight": 7 }
]';

SELECT JSON_SEARCH(@json, 'all', 'Dog'); 
 
 Ergebnis:
 +----------------------------------------------+| JSON_SEARCH(@json, 'all', "Hund") |+------------------------------------------------+ | ["$[0].type", "$[1].type"] |+------------------------------------- -----+
 
 Wenn wir all ändern zu one , Folgendes passiert:
 SET @json = '[
    { "name": "Wag", "type": "Dog", "weight": 20 },
    { "name": "Bark", "type": "Dog", "weight": 10 },
    { "name": "Meow", "type": "Cat", "weight": 7 }
]';

SELECT JSON_SEARCH(@json, 'one', 'Dog'); 
 
 Ergebnis:
 +----------------------------------------------+| JSON_SEARCH(@json, 'one', "Hund") |+-----------------------------------------------+ | "$[0].type" |+---------------------------------+
 
 Es wird nur ein Pfad zurückgegeben. 
 Geben Sie einen Pfad an
 
 Hier ist ein Beispiel, das einen Pfad angibt, nach dem im Dokument gesucht werden soll:
 SET @json = '
    { 
        "_id" : 1, 
        "name" : "Wag", 
        "details" : {
            "type" : "Dog", 
            "weight" : 20,
            "awards" : { 
                "NZ Dog Award" : "Top Dog", 
                "New York Marathon" : "Fastest Animal", 
                "Sumo 2021" : "Biggest Dog"
            }
        }
    }
';
SELECT JSON_SEARCH(
    @json, 
    'all',
    '%dog%',
    NULL,
    '$.details.awards'
    ) AS Result; 
 
 Ergebnis:
 +---------------------------------------------- -------------------+| Ergebnis |+------------------------------------------------------------ ------------------+| ["$.details.awards.NZ Dog Award", "$.details.awards.Sumo 2021"] |+------------------------ -----------------------------------------+

In diesem Fall die Zeichenfolge dog tatsächlich dreimal innerhalb des Dokuments vorkommt, aber nur zweimal unterhalb des angegebenen Pfads.

Außerdem haben wir NULL verwendet für das Escape-Zeichen-Argument, was dazu führt, dass das standardmäßige Escape-Zeichen verwendet wird, nämlich der umgekehrte Schrägstrich (\ ).

Standard-Escape-Zeichen

Standardmäßig ist das Escape-Zeichen ein umgekehrter Schrägstrich (\ ).

Beispiel:

SET @json = '[
    { "uid": "Wag", "pwd": "my%pwd" },
    { "uid": "Bark", "pwd": "my%%%pwd" },
    { "uid": "Bark", "pwd": "myBIGpwd" }
]';

SELECT 
    JSON_SEARCH(@json, 'all', 'my%pwd') AS "Not Escaped",
    JSON_SEARCH(@json, 'all', 'my\%pwd') AS "Escaped";

Ergebnis:

+-------------------------------------+------- -----+| Nicht entkommen | Entkommen |+--------------------------------------+-------- ----+| ["$[0].pwd", "$[1].pwd", "$[2].pwd"] | "$[0].pwd" |+--------------------------------------+- -----------+

Das Prozentzeichen (% ) ist ein Platzhalterzeichen, das einer beliebigen Anzahl von Zeichen entspricht. Wenn wir es also nicht maskieren, stimmt es mit einer beliebigen Anzahl von Zeichen überein, einschließlich Zeichen, die keine Prozentzeichen sind.

Aber wenn wir das Prozentzeichen mit dem Escape-Zeichen maskieren, wird es nur übereinstimmen, wenn genau ein Prozentzeichen an dieser Stelle vorhanden ist.

Die obigen Ergebnisse spiegeln dies wider.

Geben Sie ein benutzerdefiniertes Escape-Zeichen an

Sie können bei Bedarf ein benutzerdefiniertes Escape-Zeichen angeben. Geben Sie es dazu als viertes Argument an.

Beispiel:

SET @json = '[
    { "uid": "Wag", "pwd": "my%pwd" },
    { "uid": "Bark", "pwd": "my%%%pwd" },
    { "uid": "Bark", "pwd": "myBIGpwd" }
]';

SELECT 
    JSON_SEARCH(@json, 'all', 'my%pwd', '!') AS "Not Escaped",
    JSON_SEARCH(@json, 'all', 'my!%pwd', '!') AS "Escaped";

Ergebnis:

+-------------------------------------+------- -----+| Nicht entkommen | Entkommen |+--------------------------------------+-------- ----+| ["$[0].pwd", "$[1].pwd", "$[2].pwd"] | "$[0].pwd" |+--------------------------------------+- -----------+

Wir erhalten also das gleiche Ergebnis wie im vorherigen Beispiel. Der einzige Unterschied besteht darin, dass wir ein anderes Escape-Zeichen angegeben haben. In diesem Fall haben wir angegeben, dass das Ausrufezeichen (! ) ist das Fluchtzeichen.

Null-Argumente

Wenn eines der Suchzeichenfolge-, Suchzeichenfolge- oder Pfadargumente NULL ist , ist das Ergebnis NULL :

SELECT 
    JSON_SEARCH(null, 'all', 's', '', '$') AS a,
    JSON_SEARCH('{"a":1}', 'all', null, '', '$') AS b,
    JSON_SEARCH('{"a":1}', 'all', 's', '', null) AS c;

Ergebnis:

+------+------+------+| ein | b | c |+------+------+------+| NULL | NULL | NULL |+------+------+------+

Falsche Parameteranzahl

Wenn Sie keine Argumente angeben, wird ein Fehler ausgegeben:

SELECT JSON_SEARCH();

Ergebnis:

FEHLER 1582 (42000):Falsche Parameteranzahl im Aufruf der nativen Funktion „JSON_SEARCH“

Das Gleiche gilt, wenn Sie zu wenige Argumente angeben:

SELECT JSON_SEARCH('{"a":1}', 'all');

Ergebnis:

FEHLER 1582 (42000):Falsche Parameteranzahl im Aufruf der nativen Funktion „JSON_SEARCH“