One place for hosting & domains

      Verwalten

      So verwalten Sie sortierte Sets in Redis


      Einführung

      Redis ist ein Open-Source-, In-Memory-Datenspeicher mit Schlüsselwerte-Datenstruktur. Sortierte Sets in Redis sind ein Datentyp, der den Sets ähnelt. Beide sind Gruppen von Zeichenfolgen, die keine Wiederholungen zulassen. Der Unterschied besteht darin, dass in einem sortierten Set jedes Mitglied mit einem Score verknüpft ist, wodurch diese vom kleinsten bis zum größten Score sortiert werden können. So wie bei Sets darf jedes Mitglied eines sortieren Sets in diesem nur einmalig vorkommen, wobei mehrere Mitglieder den gleichen Score haben können.

      Dieses Tutorial erklärt, wie man sortierte Sets erstellt, Ihre Mitglieder abruft und entfernt und wie man neue sortierte Sets aus bestehenden Sets erstellen kann.

      So verwenden Sie diesen Leitfaden

      Dieser Leitfaden ist wie ein Spickzettel mit eigenständigen Beispielen geschrieben. Sie können beliebig zu jedem Abschnitt springen, der zu der Aufgabe passt, die Sie ausführen möchten.

      Die in diesem Leitfaden verwendeten Befehle wurden auf einem Ubuntu 18.04-Server mit der Redis-Version 4.0.9 getestet. Um eine ähnliche Umgebung einzurichten, können Sie Schritt 1 unseres Leitfadens Installieren und Sichern von Redis unter Ubuntu 18.04 folgen. Wir zeigen, wie diese Befehle sich verhalten, wenn sie mit redis-cli, der Befehlszeilenschnittstelle von Redis, angewendet werden. Beachten Sie, dass bei der Anwendung einer anderen Redis-Schnittstelle – z. B. Redli – die genaue Ausgabe bestimmter Befehle abweichen kann.

      Alternativ können Sie ein verwaltetes Exemplar einer Redis-Datenbank bereitstellen, um diese Befehle zu testen. Beachten Sie jedoch, dass abhängig vom Kontrollniveau, das Ihr Datenbankanbieter erlaubt, einige Befehle in diesem Leitfaden nicht wie beschrieben funktionieren könnten. Um eine von DigitalOcean verwaltete Datenbank bereitzustellen, folgen Sie bitte unserer Produktdokumentation über verwaltete Datenbanken. Dann müssen Sie entweder Redli installieren oder einen TLS-Tunnel einrichten, um sich mit der verwalteten Datenbank über TLS zu verbinden.

      Erstellen von sortierten Sets und Hinzufügen von Mitgliedern

      Um ein sortiertes Set zu erstellen, verwenden Sie den Befehl zadd. zadd akzeptiert als Argumente den Namen des Schlüssels, der das sortierte Set speichert, gefolgt vom Score des Mitglieds, das Sie hinzufügen, sowie dem Wert des Mitglieds selbst. Der folgende Befehl erstellt den Schlüssel eines sortierten Sets namens faveGuitarists mit einem Mitglied, "Joe Pass", das einen Score von 1 hat:

      • zadd faveGuitarists 1 "Joe Pass"

      zadd gibt eine ganze Zahl (Integer) aus, die anzeigt, wie viele Mitglieder dem sortierten Set hinzugefügt wurden, wenn es erfolgreich erstellt wurde.

      Output

      (integer) 1

      Mit zadd können Sie einem sortierten Set mehr als ein Mitglied hinzufügen. Beachten Sie, dass deren Scores nicht sequenziell sein müssen. Zwischen den Scores kann es Lücken geben und mehrere Mitglieder aus demselben sortierten Set können den gleichen Score haben:

      • zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser"

      Output

      (integer) 8

      zadd kann die folgenden Optionen akzeptieren, die Sie nach dem Schlüsselnamen und vor dem ersten Score eines Mitglieds eingeben müssen:

      • NX oder XX: Diese Optionen haben gegensätzliche Effekte, daher können Sie nur eine davon in eine zadd-Operation einfügen:
        • NX weist zadd an, die bestehenden Mitglieder nicht zu aktualisieren. Mit dieser Option fügt zadd nur neue Elemente hinzu.
        • XX weist zadd an, nur bestehende Elemente zu aktualisieren. Mit dieser Option fügt zadd niemals neue Mitglieder hinzu.
      • CH: Normalerweise gibt zadd nur die Anzahl der neuen Elemente aus, die dem sortierten Set hinzugefügt werden. Doch mit dieser Option gibt zadd die Anzahl der geänderten Elemente aus. Dazu gehören neu hinzugefügte Mitglieder sowie Mitglieder, deren Scores geändert wurden.
      • INCR: Führt dazu, dass der Befehl den Score-Wert des Mitglieds inkrementiert. Wenn das Mitglied noch nicht existiert, fügt der Befehl es mit dem Inkrement als Score in das sortierte Set ein, so als wäre sein ursprünglicher Score 0. Mit INCR gibt zadd bei erfolgreicher Ausführung den neuen Score des Mitglieds aus. Beachten Sie, dass Sie mit dieser Option jeweils nur ein Score/Mitglied-Paar einbeziehen können.

      Statt INCR mit zadd einzugeben, können Sie stattdessen den Befehl zincrby verwenden, der sich genauso verhält. Statt so wie zadd dem Mitglied des sortierten Sets den durch den Score-Wert angezeigten Wert zu geben, inkrementiert er den Score des Mitglieds auf diesen Wert. Beispiel: Der folgende Befehl inkrementiert den Score des Mitglieds "Stephen Malkmus", der ursprünglich 4 war, um 5 auf 9.

      • zincrby faveGuitarists 5 "Stephen Malkmus"

      Output

      "9"

      So wie bei der zadd-Befehlsoption INCR wird zincrby, falls das angegebene Mitglied nicht existiert, es mit dem inkrementellen Wert als seinen Score kreieren.

      Abrufen von Mitgliedern aus sortierten Sets

      Die grundlegendste Möglichkeit, die in einem sortierten Set enthaltenen Mitglieder abzurufen, ist die Verwendung des Befehls zrange. Dieser Befehl akzeptiert als Argumente den Namen des Schlüssels, dessen Mitglieder Sie abrufen möchten und eine Reihe von darin enthaltenen Mitgliedern. Die Reihe ist durch zwei Zahlen definiert, die nullbasierte Indexe repräsentieren. Das bedeutet, dass 0 das erste Mitglied im sortierten Set (oder das Mitglied mit dem niedrigsten Score) repräsentiert, 1 repräsentiert das nächste, und so fort.

      Das folgende Beispiel gibt die ersten vier Mitglieder aus dem im vorherigen Abschnitt erstellten Set faveGuitarists aus:

      • zrange faveGuitarists 0 3

      Output

      1) "Joe Pass" 2) "Rosetta Tharpe" 3) "Bola Sete" 4) "Doug Martsch"

      Beachten Sie: Falls das sortierte Set, das Sie an zrange übergeben, zwei oder mehr Elemente hat, die den gleichen Score teilen, werden diese Elemente in lexikografischer oder alphabetischer Reihenfolge sortiert.

      Die Start- und Stopp-Indizes können auch negative Zahlen sein, wobei -1 das letzte Mitglied repräsentiert, -2 das vorletzte Mitglied, und so fort:

      • zrange faveGuitarists -5 -2

      Output

      1) "Memphis Minnie" 2) "Elizabeth Cotten" 3) "Stephen Malkmus" 4) "Michael Houser"

      zrange akzeptiert zudem das Argument WITHSCORES. Wenn es enthalten ist, gibt es auch die Scores der Mitglieder aus:

      • zrange faveGuitarists 5 6 WITHSCORES

      Output

      1) "Elizabeth Cotten" 2) "8" 3) "Stephen Malkmus" 4) "9"

      zrange kann eine Reihe von Mitgliedern nur in aufsteigender numerischer Reihenfolge ausgeben. Um das umzukehren und eine Reihe in absteigender Reihenfolge auszugeben, müssen Sie den Befehl zrevrange verwenden. Stellen Sie sich diesen Befehl als vorübergehende Umkehrung der Reihenfolge des gegebenen sortierten Sets vor der Ausgabe der Mitglieder vor, die in den angegebenen Bereich fallen. Bei zrevrange repräsentiert 0 das letzte im Schlüssel enthaltene Mitglied, 1 das vorletzte, und so fort:

      • zrevrange faveGuitarists 0 5

      Output

      1) "Nancy Wilson" 2) "Michael Houser" 3) "Stephen Malkmus" 4) "Elizabeth Cotten" 5) "Memphis Minnie" 6) "Doug Martsch"

      zrevrange akzeptiert auch die Option WITHSCORES.

      Mit dem Befehl zrangebyscore können Sie eine Reihe von Mitgliedern auf der Grundlage ihrer Scores ausgeben. Im folgenden Beispiel gibt der Befehl jedes Mitglied, das im Schlüssel faveGuitarists enthalten ist und einen Score von 2, 3 oder 4 hat, aus:

      • zrangebyscore faveGuitarists 2 4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 4) "Memphis Minnie"

      In diesem Beispiel ist die Reihe integrativ. Das bedeutet, dass sie Mitglieder mit Scores von 2 oder 4 ausgibt. Sie können jedes Ende der Reihe ausschließen, indem Sie eine offene Klammer davorsetzen ((). Das folgende Beispiel gibt jedes Mitglied mit einem Score, der größer oder gleich 2, jedoch kleiner als 4 ist, aus:

      • zrangebyscore faveGuitarists 2 (4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      So wie bei zrange akzeptiert zrangebyscore das Argument WITHSCORES. Außerdem akzeptiert es die Option LIMIT, die Sie verwenden können, um nur eine Auswahl von Elementen aus der Ausgabe von zrangebyscore abzurufen. Diese Option akzeptiert ein Offset, das das erste Mitglied in der Reihe markiert, die der Befehl zurückgibt, sowie einen Zählstand, der festlegt, wie viele Mitglieder der Befehl insgesamt ausgibt. Der folgende Befehl z. B. konzentriert sich auf die ersten sechs Mitglieder des sortierten Sets faveGuitarists, gibt aber nur 3 dieser Mitglieder aus, beginnend mit dem zweiten Mitglied in der Reihe, repräsentiert durch 1:

      • zrangebyscore faveGuitarists 0 5 LIMIT 1 3

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Der Befehl zrevrangebyscore gibt eine umgekehrte Reihe von Mitgliedern auf der Grundlage ihrer Scores aus. Der folgende Befehl gibt jedes Mitglied des Sets mit einem Score zwischen 10 und 6 aus:

      • zrevrangebyscore faveGuitarists 10 6

      Output

      1) "Stephen Malkmus" 2) "Elizabeth Cotten"

      So wie bei zrangebyscore kann zrevrangebyscore sowohl die Option WITHSCORES als auch die Option LIMIT akzeptieren. Außerdem können Sie jedes Ende der Reihe ausschließen, indem Sie vor dieses eine offene Klammer setzen.

      Es kann vorkommen, dass alle Mitglieder in einem sortierten Set den gleichen Score haben. In einem solchen Fall können Sie redis zwingen, mit dem Befehl zrangebylex eine Reihe von Elementen, die in lexikografischer oder in alphabetischer Reihenfolge sortiert sind, auszugeben. Um diesen Befehl auszuprobieren, führen Sie den folgenden zadd-Befehl aus, um ein sortiertes Set zu erstellen, in dem jedes Mitglied den gleichen Score hat:

      • zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly

      Auf zrangebylex müssen ein Schlüsselname, ein Startintervall und ein Stoppinterval folgen. Die Start- und Stoppintervalle müssen mit einer offenen runden Klammer (() oder einer offenen eckigen Klammer ([) beginnen:

      • zrangebylex SomervilleSquares [a [z

      Output

      1) "assembly" 2) "ball" 3) "magoun" 4) "porter"

      Beachten Sie, dass dieses Beispiel nur vier der acht Mitglieder im Set ausgegeben hat, obwohl der Befehl eine Reihe von a bis z suchte. Das liegt daran, dass Redis-Werte groß-/kleinschreibungsabhängig sind. Daher wurden die Mitglieder, die mit Großbuchstaben beginnen, aus der Ausgabe ausgeschlossen. Um diese auszugeben, können Sie Folgendes ausführen:

      • zrangebylex SomervilleSquares [A [z

      Output

      1) "Davis" 2) "Inman" 3) "Union" 4) "assembly" 5) "ball" 6) "magoun" 7) "porter"

      zrangebylex akzeptiert auch die Sonderzeichen -, das negative Unendlichkeit, und +, das positive Unendlichkeit darstellt. Daher gibt die folgende Befehlssyntax auch jedes Mitglied des sortierten Sets aus:

      • zrangebylex SomervilleSquares - +

      Beachten Sie, dass zrangebylex Mitglieder eines sortierten Sets nicht in umgekehrter lexikografischer (ansteigend alphabetischer) Reihenfolge ausgeben kann. Hierfür verwenden Sie zrevrangebylex:

      • zrevrangebylex SomervilleSquares + -

      Output

      1) "porter" 2) "magoun" 3) "ball" 4) "assembly" 5) "Union" 6) "Inman" 7) "Davis"

      Da es für die Verwendung mit sortierten Sets bestimmt ist, bei denen jedes Mitglied den gleichen Score hat, akzeptiert zrangebylex nicht die Option WITHSCORES. Es akzeptiert jedoch die Option LIMIT.

      Abrufen von Informationen aus sortierten Sets

      Um herauszufinden, wie viele Mitglieder sich in einem gegebenen sortierten Set befinden (oder anders ausgedrückt, um seine Kardinalität zu bestimmen), verwenden Sie den Befehl zcard. Das folgende Beispiel zeigt, wie viele Mitglieder im Schlüssel faveGuitarists aus dem ersten Abschnitt dieses Leitfadens enthalten sind:

      Output

      (integer) 9

      zcount kann Ihnen zeigen, wie viele Elemente in einem gegebenen sortierten Set enthalten sind, die in einen Bereich von Scores fallen. Die erste Zahl, die auf den Schlüssel folgt, ist der Beginn des Bereichs und die zweite das Ende des Bereichs:

      • zcount faveGuitarists 3 8

      Output

      (integer) 4

      zscore gibt den Score eines angegebenen Mitglieds eines sortierten Sets aus:

      • zscore faveGuitarists "Bola Sete"

      Output

      "3"

      Wenn entweder das angegebene Mitglied oder der Schlüssel nicht existieren, gibt zscore als Ausgabe (nil) an.

      zrank ist ähnlich wie zscore, aber anstatt den Score des gegebenen Mitglieds auszugeben, gibt es stattdessen seinen Rang aus. In Redis ist Rang – rank – ein nullbasierter Index der Mitglieder eines sortierten Sets, der nach ihrem Score geordnet wird. Beispielsweise hat "Joe Pass" einen Score von 1, aber weil dies der niedrigste Score aller Mitglieder im Schlüssel ist, hat er den Rang 0:

      • zrank faveGuitarists "Joe Pass"

      Output

      (integer) 0

      Ein weiterer Redis-Befehl namens zrevrank führt die gleiche Funktion wie zrank aus, kehrt aber stattdessen den Rang der Mitglieder im Set um. Im folgenden Beispiel hat das Mitglied "Joe Pass" den niedrigsten Score und daraus folgend den höchsten umgekehrten Rang:

      • zrevrank faveGuitarists "Joe Pass"

      Output

      (integer) 8

      Die einzige Beziehung zwischen dem Score eines Mitglieds und seinem Rang besteht darin, wo sein Score im Verhältnis zu dem der anderen Mitglieder steht. Wenn zwischen zwei aufeinanderfolgenden Mitgliedern eine Lücke beim Score besteht, reflektiert sich diese nicht in ihrem Rang. Beachten Sie: Wenn zwei Mitglieder den gleichen Score haben, nimmt das Mitglied, das alphabetisch zuerst kommt, den unteren Rang ein.

      Wie zscore geben zrank und zrevrank als Ausgabe (nil) an, wenn der Schlüssel oder das Mitglied nicht existiert.

      zlexcount kann Ihnen zeigen, wie viele Mitglieder in einem sortierten Set innerhalb eines lexikografischen Bereichs enthalten sind. Das folgende Beispiel verwendet das sortierte Set SomervilleSquares aus dem vorherigen Abschnitt:

      • zlexcount SomervilleSquares [M [t

      Output

      (integer) 5

      Dieser Befehl folgt derselben Syntax wie der Befehl zrangebylex. Einzelheiten zum Definieren eines Stringbereichs entnehmen Sie dem vorherigen Abschnitt.

      Entfernen von Mitgliedern aus sortierten Sets

      Der Befehl zrem kann ein oder mehrere Mitglieder aus einem sortierten Set entfernen:

      • zrem faveGuitarists "Doug Martsch" "Bola Sete"

      zrem gibt eine ganze Zahl aus, die anzeigt, wie viele Mitglieder aus dem sortierten Set entfernt wurden:

      Output

      (integer) 2

      Es gibt drei Redis-Befehle, die es Ihnen ermöglichen, Mitglieder eines sortierten Sets auf der Grundlage eines Bereichs zu entfernen. Wenn z. B. jedes Mitglied in einem sortierten Set den gleichen Score hat, können Sie Mitglieder auf der Grundlage eines lexikografischen Bereichs mit zremrangebylex entfernen. Dieser Befehl verwendet die gleiche Syntax wie zrangebylex. Das folgende Beispiel entfernt jedes Mitglied, das mit einem Großbuchstaben beginnt, aus dem im vorherigen Abschnitt erstellten Schlüssel SomervilleSquares:

      • zremrangebylex SomervilleSquares [A [Z

      zremrangebylex gibt eine ganze Zahl an, die anzeigt, wie viele Mitglieder entfernt wurden:

      Output

      (integer) 3

      Außerdem können Sie Mitglieder auf der Grundlage eines Score-Bereichs mit dem Befehl zremrangebyscore entfernen, der die gleiche Syntax wie der Befehl zrangebyscore verwendet. Das folgende Beispiel entfernt jedes in faveGuitarists enthaltene Mitglied mit einem Score von 4, 5 oder 6:

      • zremrangebyscore faveGuitarists 4 6

      Output

      (integer) 1

      Sie können Mitglieder aus einem Set auf der Grundlage eines Rangbereichs mit dem Befehl zremrangebyrank entfernen, der die gleiche Syntax wie zrangebyrank verwendet. Der folgende Befehl entfernt die drei Mitglieder des sortierten Sets mit den niedrigsten Rängen, die durch einen Bereich von nullbasierten Indizes definiert sind:

      • zremrangebyrank faveGuitarists 0 2

      Output

      (integer) 3

      Beachten Sie, dass an remrangebyrank übergebene Zahlen auch negativ sein können, wobei -1 den höchsten Rang repräsentiert, -2 den nächsthöheren, und so fort.

      Erstellen von neuen sortierten Sets aus bestehenden Sets

      Redis enthält zwei Befehle, die es Ihnen ermöglichen, Mitglieder mehrerer sortierter Sets zu vergleichen und auf der Grundlage dieser Vergleiche neue Sets zu erstellen: zinterstore und zunionstore. Um diese Befehle auszuprobieren, führen Sie die folgenden zadd-Befehle aus, um einige sortierte Beispielsets zu erstellen.

      • zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny"
      • zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC"

      zinterstore findet die Mitglieder, die von zwei oder mehreren sortierten Sets geteilt werden – deren Schnittmenge – und erzeugt ein neues sortiertes Set, das nur diese Mitglieder enthält. Dieser Befehl muss den Namen eines Zielschlüssels, in dem die sich überschneidenden Mitglieder als sortiertes Set gespeichert werden, die Anzahl der an zinterstore übergebenden Schlüssel und die Namen der Schlüssel, die Sie analysieren möchten, in der Reihenfolge enthalten:

      • zinterstore BoyBands 2 NewKids Nsync

      zinterstore gibt dann eine ganze Zahl aus, die die Anzahl der im sortierten Zielset gespeicherten Elemente anzeigt. Da NewKids und Nsync nur ein Mitglied teilen – "Joey"– gibt der Befehl 1 aus:

      Output

      (integer) 1

      Bitte beachten Sie: Falls der Zielschlüssel bereits existiert, überschreibt zinterstore dessen Inhalt.

      zunionstore erstellt ein neues sortiertes Set, das jedes Mitglied der an den Befehl übergebenen Schlüssel enthält. Dieser Befehl verwendet die gleiche Syntax wie zinterstore und erfordert den Namen eines Zielschlüssels, die Anzahl der an den Befehl übergebenen Schlüssel und die Namen der Schlüssel:

      • zunionstore SuperGroup 2 NewKids Nsync

      Wie zinterstore gibt zunionstore eine ganze Zahl aus, die die Anzahl der im Zielschlüssel gespeicherten Elemente anzeigt. Obwohl beide der ursprünglich sortierten Sets fünf Mitglieder enthalten, die sortierten Sets jedoch keine sich wiederholenden Mitglieder enthalten können und jeder Schlüssel ein Mitglied mit dem Namen "Joey" beinhaltet, ist die resultierende ganze Zahl 9:

      Output

      (integer) 9

      Wie zinterstore überschreibt zunionstore den Inhalt des Zielschlüssels, wenn dieser bereits existiert.

      Um Ihnen beim Erstellen von neuen sortierten Sets mit zinterstore und zunionstore mehr Kontrolle über die Scores der Mitglieder zu geben, akzeptieren beide Befehle die Optionen WEIGHTS und AGGREGATE.

      Auf die Option WEIGHTS folgt eine Zahl für jedes im Befehl enthaltene sortierte Set, welche die Scores jedes Mitglieds bewertet oder vervielfacht. Die erste Zahl nach der Option WEIGHTS bewertet die Scores des ersten an den Befehl übergebenen Schlüssels, die zweite Zahl den zweiten Schlüssel, und so fort.

      Das folgende Beispiel erstellt ein neues sortiertes Set, das die überschneidenden Schlüssel aus den sortierten Sets NewKids und Nsync enthält. Es bewertet die Scores im Schlüssel NewKids mit dem Faktor drei und die im Schlüssel Nsync mit dem Faktor sieben:

      • zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7

      Wenn die Option WEIGHTS nicht enthalten ist, wird die Bewertung standardmäßig auf 1 gesetzt, sowohl für zinterstore als auch für zunionstore.

      AGGREGATE akzeptiert drei Suboptionen. Die erste davon, SUM, implementiert das Standardverhalten von zinterstore und zunionstore, indem sie die Scores von übereinstimmenden Mitgliedern den kombinierten Sets hinzufügt.

      Wenn Sie in zwei sortierten Sets, die ein Mitglied teilen, eine zinterstore– oder zunionstore-Operation ausführen, dieses Mitglied aber in jedem Set einen anderen Score hat, können Sie die Operation mit der Suboption MIN zwingen, den niedrigeren der beiden Punktstände zuzuweisen.

      • zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN

      Da die beiden sortierten Sets nur ein übereinstimmendes Mitglied mit dem gleichen Score (3) haben, erstellt dieser Befehl ein neues Set mit einem Mitglied, das den niedrigeren der beiden bewerteten Scores hat:

      • zscore BoyBandsWeightedMin "Joey"

      Output

      "9"

      Ebenso kann AGGREGATE zinterstore oder zunionstore zwingen, mit der Option MAX den höheren der beiden Scores zuzuweisen:

      • zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX

      Dieser Befehl erstellt ein neues Set mit einem Mitglied, "Joey", das den höheren der beiden bewerteten Scores hat:

      • zscore BoyBandsWeightedMax "Joey"

      Output

      "21"

      Es kann hilfreich sein, sich WEIGHTS als eine Möglichkeit vorzustellen, die Scores von Mitgliedern vorübergehend zu manipulieren, bevor sie analysiert werden. Ebenso ist es hilfreich, sich die Option AGGREGATE als Entscheidungsmöglichkeit vorzustellen, wie die Scores der Mitglieder kontrolliert werden können, bevor sie in ihre neuen Sets aufgenommen werden.

      Zusammenfassung

      Dieser Leitfaden erläutert eine Reihe von Befehlen, die zur Erstellung und Verwaltung von sortierten Sets in Redis verwendet werden. Wenn es andere verwandte Befehle, Argumente oder Verfahren gibt, die Sie in diesem Leitfaden erklärt sehen möchten, schreiben Sie bitte eine Frage oder einen Vorschlag in das Kommentarfeld unten.

      Weitere Informationen zu Redis finden Sie in unserer Tutorialserie Verwalten einer Redis-Datenbank.



      Source link

      Verwalten und Verwenden von MySQL-Datenbank-Triggern unter Ubuntu 18.04


      Der Autor hat die Apache Software Foundation dazu ausgewählt, im Rahmen des Programms Write for DOnations eine Spende zu erhalten.

      Einführung

      In MySQL ist ein trigger ein benutzerdefinierter SQL-Befehl, der während eines INSERT-, DELETE– oder UPDATE-Vorgangs automatisch aufgerufen wird. Der Triggercode ist mit einer Tabelle verbunden und wird nach dem Verwerfen einer Tabelle zerstört. Sie können eine Triggeraktionszeit festlegen und bestimmen, ob die Triggeraktion vor oder nach dem definierten Datenbankereignis ausgelöst werden soll.

      Trigger bieten verschiedene Vorteile. Sie können sie beispielsweise verwenden, um bei einer INSERT-Anweisung den Wert einer abgeleiteten Spalte zu generieren. Ein weiterer Anwendungsfall ist die Durchsetzung der referenziellen Integrität, wo Sie einen Trigger verwenden können, um einen Eintrag in mehreren verknüpften Tabellen zu speichern. Weitere Vorteile sind die Protokollierung von Benutzeraktionen in Prüftabellen sowie das Live-Kopieren von Daten in verschiedenen Datenbankschemata für Redundanzzwecke, um einzelne Ausfallpunkte (Single Points of Failure) zu verhindern.

      Sie können Trigger außerdem verwenden, um Validierungsregeln auf der Datenbankebene zu pflegen. So können Sie die Datenquelle in mehreren Anwendungen freigeben, ohne die Geschäftslogik zu stören. Dadurch werden Roundtrips zum Datenbankserver stark reduziert, was die Antwortzeit Ihrer Anwendungen verbessert. Da der Datenbankserver Trigger ausführt, können Sie auch optimierte Serverressourcen wie RAM und CPU nutzen.

      In diesem Tutorial erstellen, verwenden und löschen Sie verschiedene Arten von Triggern in Ihrer MySQL-Datenbank.

      Voraussetzungen

      Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

      Schritt 1 — Erstellen einer Beispieldatenbank

      In diesem Schritt erstellen Sie eine exemplarische Kundendatenbank mit mehreren Tabellen, um zu sehen, wie MySQL-Trigger funktionieren.

      Wenn Sie mehr über MySQL-Abfragen wissen möchten, lesen Sie unsere Einführung zu Abfragen in MySQL.

      Melden Sie sich zunächst als root user bei Ihrem MySQL-Server an:

      Geben Sie auf Aufforderung Ihr MySQL-Root-Passwort ein und drücken Sie zum Fortfahren die Eingabetaste. Wenn Sie die Eingabeaufforderung mysql> sehen, führen Sie folgenden Befehl aus, um eine test_db-Datenbank zu erstellen:

      Output

      Query OK, 1 row affected (0.00 sec)

      Wechseln Sie als Nächstes zu test_db mit:

      Output

      Database changed

      Sie erstellen zunächst eine Tabelle namens customers. Diese Tabelle wird die Datensätze von Kunden enthalten, einschließlich customer_id, customer_name und level. Es wird zwei Kundenlevel geben: BASIC und VIP.

      • Create table customers(customer_id BIGINT PRIMARY KEY, customer_name VARCHAR(50), level VARCHAR(50) ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.01 sec)

      Fügen Sie nun der Tabelle customers ein paar Einträge hinzu. Führen Sie dazu nacheinander folgende Befehle aus:

      • Insert into customers (customer_id, customer_name, level )values('1','JOHN DOE','BASIC');
      • Insert into customers (customer_id, customer_name, level )values('2','MARY ROE','BASIC');
      • Insert into customers (customer_id, customer_name, level )values('3','JOHN DOE','VIP');

      Sie erhalten nach dem Ausführen der einzelnen INSERT-Befehle folgende Ausgabe:

      Output

      Query OK, 1 row affected (0.01 sec)

      Um zu überprüfen, ob die Beispieleinträge erfolgreich eingefügt wurden, führen Sie den Befehl SELECT aus:

      Output

      +-------------+---------------+-------+ | customer_id | customer_name | level | +-------------+---------------+-------+ | 1 | JOHN DOE | BASIC | | 2 | MARY ROE | BASIC | | 3 | JOHN DOE | VIP | +-------------+---------------+-------+ 3 rows in set (0.00 sec)

      Außerdem erstellen Sie eine weitere Tabelle, um entsprechende Informationen über das Konto customers zu speichern. Die Tabelle wird über die Felder customer_id und status_notes verfügen.

      Führen Sie den folgenden Befehl aus:

      • Create table customer_status(customer_id BIGINT PRIMARY KEY, status_notes VARCHAR(50)) ENGINE=INNODB;

      Als Nächstes erstellen Sie eine Tabelle namens sales (Verkäufe). In dieser Tabelle werden über die Spalte customer_id Verkaufsdaten für die verschiedenen Kunden gespeichert:

      • Create table sales(sales_id BIGINT PRIMARY KEY, customer_id BIGINT, sales_amount DOUBLE ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.01 sec)

      In den nächsten Schritten fügen Sie den sales-Daten beim Testen der Trigger Beispieldaten hinzu. Als Nächstes erstellen Sie eine Tabelle namens audit_log, um an der Tabelle sales vorgenommene Aktualisierungen zu protokollieren, wenn Sie den Trigger AFTER UPDATE in Schritt 5 implementieren:

      • Create table audit_log(log_id BIGINT PRIMARY KEY AUTO_INCREMENT, sales_id BIGINT, previous_amount DOUBLE, new_amount DOUBLE, updated_by VARCHAR(50), updated_on DATETIME ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.02 sec)

      Nachdem Sie über die Datenbank test_db und die vier Tabellen verfügen, fahren Sie nun mit den verschiedenen MySQL-Triggern in Ihrer Datenbank fort.

      Schritt 2 — Erstellen eines Before Insert-Triggers

      In diesem Schritt prüfen Sie die Syntax eines MySQL-Triggers, bevor Sie diese Logik anwenden, um einen BEFORE INSERT-Trigger zu erstellen, der das Feld sales_amount beim Einfügen von Daten in die Tabelle sales validiert.

      Die allgemeine Syntax zum Erstellen eines MySQL-Triggers wird im folgenden Beispiel gezeigt:

      DELIMITER //
      CREATE TRIGGER [TRIGGER_NAME]
      [TRIGGER TIME] [TRIGGER EVENT]
      ON [TABLE]
      FOR EACH ROW
      [TRIGGER BODY]//
      DELIMITER ;
      

      Die Struktur des Triggers umfasst:

      DELIMITER //: Das Standardtrennzeichen von MySQL ist ; – es ist notwendig, das Zeichen zu ändern, wenn MySQL folgende Zeilen als einen Befehl behandeln soll, bis er auf Ihr benutzerdefiniertes Trennzeichen trifft. In diesem Beispiel wird das Trennzeichen in // geändert und das Trennzeichen ; wird am Ende neu definiert.

      [TRIGGER_NAME]: Ein Trigger muss einen Namen haben; hier schließen Sie den Wert ein.

      [TRIGGER TIME]: Ein Trigger kann zu verschiedenen Zeitpunkten aufgerufen werden. Mit MySQL können Sie definieren, ob der Trigger vor oder nach der Datenbankoperation gestartet werden soll.

      [TRIGGER EVENT]: Trigger werden nur von INSERT-, UPDATE– und DELETE-Operationen aufgerufen. Sie können hier einen beliebigen Wert verwenden, je nach dem, was Sie erreichen möchten.

      [TABLE]: Jeder Trigger, den Sie in der MySQL-Datenbank erstellen, muss mit einer Tabelle verknüpft werden.

      FOR EACH ROW: Diese Anweisung informiert MySQL, dass der Triggercode für jede Zeile ausgeführt werden soll, auf die sich der Trigger auswirkt.

      [TRIGGER BODY]: Der Code, der beim Aufruf des Triggers ausgeführt wird, wird als Trigger Body bezeichnet. Dabei kann es sich um eine einzelne SQL-Anweisung oder mehrere Befehle handeln. Hinweis: Wenn Sie mehrere SQL-Anweisungen auf den Trigger Body ausführen, müssen Sie diese zwischen einem BEGIN... END-Block einschließen.

      Anmerkung: Beim Erstellen des Trigger Body können Sie die Schlüsselwörter OLD und NEW verwenden, um die bei einem INSERT-, UPDATE– und DELETE-Vorgang eingegebenen alten und neuen Spaltenwerte aufzurufen. In einem DELETE-Trigger kann nur das Schlüsselwort OLD verwendet werden (was Sie in Schritt 4 nutzen werden).

      Nun erstellen Sie Ihren ersten BEFORE INSERT-Trigger. Dieser Trigger wird mit der Tabelle sales verbunden und aufgerufen, bevor ein Eintrag eingefügt wird, um die Verkaufssumme (sales_amount) zu validieren. Aufgabe des Triggers ist es zu prüfen, ob die in die Umsatztabelle eingefügte Verkaufssumme (sales_amount) höher als 10000 ist und einen Fehler ergeben soll, wenn zu true ausgewertet wird.

      Stellen Sie sicher, dass Sie beim MySQL-Server angemeldet sind. Geben Sie dann nacheinander folgende MySQL-Befehle ein:

      • DELIMITER //
      • CREATE TRIGGER validate_sales_amount
      • BEFORE INSERT
      • ON sales
      • FOR EACH ROW
      • IF NEW.sales_amount>10000 THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
      • END IF//
      • DELIMITER ;

      Sie verwenden die IF... THEN... END IF-Anweisung, um auszuwerten, ob die bei der INSERT-Anweisung bereitgestellte Summe innerhalb Ihres Bereichs liegt. Der Trigger kann den neu bereitgestellten Wert von sales_amount durch Verwendung des Schlüsselworts NEW extrahieren.

      Zum Ausgeben einer generischen Fehlermeldung verwenden Sie folgende Zeilen, um den Benutzer über den Fehler zu informieren:

      SIGNAL SQLSTATE '45000'
      SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
      

      Als Nächstes fügen Sie einen Eintrag mit der Verkaufssumme (sales_amount) 11000 zur Tabelle sales hinzu, um zu überprüfen, ob der Trigger die Operation stoppen wird:

      • Insert into sales(sales_id, customer_id, sales_amount) values('1','1','11000');

      Output

      ERROR 1644 (45000): Sale has exceeded the allowed amount of 10000.

      Dieser Fehler zeigt, dass der Triggercode wie erwartet funktioniert.

      Probieren Sie es nun mit einem neuen Eintrag, der den Wert 7500 hat, um zu überprüfen, ob der Befehl erfolgreich ausgeführt wird:

      • Insert into sales(sales_id, customer_id, sales_amount) values('1','1','7500');

      Da der Wert im empfohlenen Bereich liegt, sehen Sie die folgende Ausgabe:

      Output

      Query OK, 1 row affected (0.01 sec)

      Um zu überprüfen, ob die Daten eingefügt wurden, führen Sie folgenden Befehl aus:

      Die Ausgabe zeigt, dass sich die Daten in der Tabelle befinden:

      Output

      +----------+-------------+--------------+ | sales_id | customer_id | sales_amount | +----------+-------------+--------------+ | 1 | 1 | 7500 | +----------+-------------+--------------+ 1 row in set (0.00 sec)

      In diesem Schritt haben Sie Trigger getestet, um Daten zu validieren, bevor sie in eine Datenbank eingefügt werden.

      Als Nächstes verwenden Sie den AFTER INSERT-Trigger, um verwandte Daten in verschiedene Tabellen zu speichern.

      Schritt 3 — Erstellen eines After Insert-Triggers

      AFTER INSERT-Trigger werden ausgeführt, wenn Einträge erfolgreich in eine Tabelle eingefügt werden. Diese Funktion kann dazu dienen, andere geschäftliche Logiken automatisch auszuführen. In einer Bankanwendung kann beispielsweise ein AFTER INSERT-Trigger ein Kreditkonto schließen, sobald ein Kunde seinen Kredit abbezahlt hat. Der Trigger kann alle in eine Transaktionstabelle eingefügten Zahlungen überwachen und den Kredit automatisch schließen, sobald das Kreditsaldo null beträgt.

      In diesem Schritt arbeiten Sie mit der Tabelle customer_status und verwenden einen AFTER INSERT-Trigger, um verwandte Kundeneinträge einzugeben.

      Um den AFTER INSERT-Trigger zu erstellen, geben Sie folgende Befehle ein:

      • DELIMITER //
      • CREATE TRIGGER customer_status_records
      • AFTER INSERT
      • ON customers
      • FOR EACH ROW
      • Insert into customer_status(customer_id, status_notes) VALUES(NEW.customer_id, 'ACCOUNT OPENED SUCCESSFULLY')//
      • DELIMITER ;

      Output

      Query OK, 0 rows affected (0.00 sec)

      Hier weisen Sie MySQL an, einen weiteren Eintrag in der Tabelle customer_status zu speichern, sobald ein neuer Kundendateneintrag in die Tabelle customers eingefügt wird.

      Fügen Sie nun einen neuen Eintrag in die Tabelle customers ein, um zu bestätigen, dass Ihr Triggercode aufgerufen wird:

      • Insert into customers (customer_id, customer_name, level )values('4','DAVID DOE','VIP');

      Output

      Query OK, 1 row affected (0.01 sec)

      Nachdem der Eintrag erfolgreich eingefügt wurde, überprüfen Sie, ob in die Tabelle customer_status ein neuer Statuseintrag eingefügt wurde:

      • Select * from customer_status;

      Output

      +-------------+-----------------------------+ | customer_id | status_notes | +-------------+-----------------------------+ | 4 | ACCOUNT OPENED SUCCESSFULLY | +-------------+-----------------------------+ 1 row in set (0.00 sec)

      Die Ausgabe zeigt, dass der Trigger erfolgreich ausgeführt wurde.

      Der AFTER INSERT-Trigger hilft dabei, den Lebenszyklus eines Kunden zu überwachen. In einer Produktionsumgebung können Konten von Kunden verschiedene Stufen durchlaufen, wie Eröffnen, Suspendieren und Schließen.

      In den folgenden Schritten arbeiten Sie mit UPDATE-Triggern.

      Schritt 4 — Erstellen eines Before Update-Triggers

      Ein BEFORE UPDATE-Trigger ähnelt dem BEFORE INSERT-Trigger – er wird jedoch zu einem anderen Zeitpunkt aufgerufen. Sie können den BEFORE UPDATE-Trigger verwenden, um eine Geschäftslogik zu überprüfen, bevor ein Eintrag aktualisiert wird. Verwenden Sie zum Testen die Tabelle customers, in der Sie bereits Daten eingefügt haben.

      Sie verfügen in der Datenbank über zwei verschiedene Level für Ihre Kunden. In diesem Beispiel kann ein Kundenkonto nach dem Hochstufen auf das Level VIP nicht mehr auf das Level BASIC herabgestuft werden. Um eine solche Regel durchzusetzen, erstellen Sie einen BEFORE UPDATE-Trigger, der vor der UPDATE-Anweisung ausgeführt wird (wie nachfolgend gezeigt). Wenn ein Datenbankbenutzer einen Kunden auf das Level BASIC herunterstufen will (vom Level VIP aus), wird eine benutzerdefinierte Ausnahme ausgelöst.

      Geben Sie nacheinander folgende SQL-Befehle ein, um den BEFORE UPDATE-Trigger zu erstellen:

      • DELIMITER //
      • CREATE TRIGGER validate_customer_level
      • BEFORE UPDATE
      • ON customers
      • FOR EACH ROW
      • IF OLD.level='VIP' THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'A VIP customer can not be downgraded.';
      • END IF //
      • DELIMITER ;

      Verwenden Sie das Schlüsselwort OLD, um das Level zu erfassen, das der Benutzer beim Ausführen des Befehls UPDATE bereitstellt. Auch hier verwenden Sie die IF... THEN... END IF-Anweisung, um dem Benutzer eine generische Fehlermeldung anzuzeigen.

      Führen Sie als Nächstes den folgenden SQL-Befehl aus, der versucht, ein mit der customer_id 3 verbundenes Kundenkonto herabzustufen:

      • Update customers set level='BASIC' where customer_id='3';

      Sie sehen die folgende Ausgabe, die den SET MESSAGE_TEXT bereitstellt:

      Output

      ERROR 1644 (45000): A VIP customer can not be downgraded.

      Wenn Sie den gleichen Befehl für einen BASIC-Kunden ausführen und versuchen, das Konto auf das Level VIP hochzustufen, wird der Befehl erfolgreich ausgeführt:

      • Update customers set level='VIP' where customer_id='1';

      Output

      Rows matched: 1 Changed: 1 Warnings: 0

      Sie haben den BEFORE UPDATE-Trigger verwendet, um eine Geschäftsregel durchzusetzen. Jetzt fahren Sie mit der Verwendung eines AFTER UPDATE-Triggers zur Überwachungsprotokollierung fort.

      Schritt 3 — Erstellen eines After Update-Triggers

      Ein AFTER UPDATE-Trigger wird aufgerufen, sobald ein Datenbankeintrag erfolgreich aktualisiert wurde. Dieses Verhalten sorgt dafür, dass sich der Trigger für die Überwachungsprotokollierung eignet. In einer Umgebung mit mehreren Benutzern möchte der Administrator aus Auditgründen möglicherweise einen Verlauf der Benutzer anzeigen, die Einträge in einer bestimmten Tabelle aktualisiert haben.

      Sie erstellen einen Trigger, der die Aktualisierungsaktivität der Tabelle sales protokolliert. Die Tabelle audit_log enthält Informationen über die MySQL-Benutzer, die die Tabelle sales aktualisieren, das Datum der Aktualisierung und die neuen und alten Werte von sales_amount.

      Um den Trigger zu erstellen, führen Sie folgende SQL-Befehle aus:

      • DELIMITER //
      • CREATE TRIGGER log_sales_updates
      • AFTER UPDATE
      • ON sales
      • FOR EACH ROW
      • Insert into audit_log(sales_id, previous_amount, new_amount, updated_by, updated_on) VALUES (NEW.sales_id,OLD.sales_amount, NEW.sales_amount,(SELECT USER()), NOW() )//
      • DELIMITER ;

      Sie fügen in die Tabelle audit_log einen neuen Eintrag ein. Sie verwenden das Schlüsselwort NEW, um den Wert der sales_id und die neue Verkaufssumme (sales_amount) abzurufen. Außerdem verwenden Sie das Schlüsselwort OLD, um die vorherige Verkaufssumme (sales_amount) abzurufen, da Sie für Auditzwecke beide Beträge protokollieren möchten.

      Der Befehl SELECT USER() ruft den aktuellen Benutzer ab, der die Operation ausführt; die Anweisung NOW() ruft den Wert des aktuellen Datums und der Uhrzeit vom MySQL-Server ab.

      Wenn nun ein Benutzer versucht, den Wert eines beliebigen Eintrags in der Tabelle sales zu aktualisieren, wird der Trigger log_sales_updates einen neuen Eintrag in die Tabelle audit_log einfügen.

      Nun erstellen wir einen neuen Verkaufseintrag mit einer zufälligen Verkaufs-ID (sales_id) von 5 und versuchen, ihn zu aktualisieren. Fügen Sie zunächst den Verkaufseintrag ein mit:

      • Insert into sales(sales_id, customer_id, sales_amount) values('5', '2','8000');

      Output

      Query OK, 1 row affected (0.00 sec)

      Aktualisieren Sie als Nächstes den Eintrag:

      • Update sales set sales_amount='9000' where sales_id='5';

      Sie sehen die folgende Ausgabe:

      Output

      Rows matched: 1 Changed: 1 Warnings: 0

      Führen Sie nun den folgenden Befehl aus, um zu überprüfen, ob der AFTER UPDATE-Trigger einen neuen Eintrag in der Tabelle audit_log registrieren konnte:

      Der Trigger hat die Aktualisierung protokolliert. Die Ausgabe zeigt die vorherige Verkaufssumme (sales_amount) und die neue Summe (new amount), die für den Benutzer registriert sind, der die Einträge aktualisiert hat:

      Output

      +--------+----------+-----------------+------------+----------------+---------------------+ | log_id | sales_id | previous_amount | new_amount | updated_by | updated_on | +--------+----------+-----------------+------------+----------------+---------------------+ | 1 | 5 | 8000 | 9000 | root@localhost | 2019-11-07 09:28:36 | +--------+----------+-----------------+------------+----------------+---------------------+ 1 row in set (0.00 sec)

      Außerdem verfügen Sie über Datum und Uhrzeit der vorgenommenen Aktualisierung, was für Auditzwecke nützlich ist.

      Als Nächstes verwenden Sie den DELETE-Trigger, um auf der Ebene der Datenbank die referenzielle Integrität durchzusetzen.

      Schritt 6 — Erstellen eines Before Delete-Triggers

      BEFORE DELETE-Trigger werden aufgerufen, bevor in einer Tabelle eine DELETE-Anweisung ausgeführt wird. Diese Arten von Triggern dienen normalerweise dazu, die referenzielle Integrität verschiedener verbundener Tabellen sicherzustellen. Beispielsweise bezieht sich jeder Eintrag in der Tabelle sales auf eine customer_id aus der Tabelle customers. Wenn ein Datenbankbenutzer einen Eintrag aus der Tabelle customers gelöscht hat, der in der Tabelle sales einen verknüpften Eintrag enthält, hätten Sie keine Möglichkeit zu wissen, welcher Kunde mit diesem Eintrag verknüpft war.

      Um das zu verhindern, können Sie zum Durchsetzen Ihrer Logik einen BEFORE DELETE-Trigger erstellen. Führen Sie nacheinander folgende SQL-Befehle aus:

      • DELIMITER //
      • CREATE TRIGGER validate_related_records
      • BEFORE DELETE
      • ON customers
      • FOR EACH ROW
      • IF OLD.customer_id in (select customer_id from sales) THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'The customer has a related sales record.';
      • END IF//
      • DELIMITER ;

      Versuchen Sie nun, einen Kunden zu löschen, der über einen verknüpften Verkaufseintrag verfügt:

      • Delete from customers where customer_id='2';

      Dadurch erhalten Sie die folgende Ausgabe:

      Output

      ERROR 1644 (45000): The customer has a related sales record.

      Der BEFORE DELETE-Trigger kann ein versehentliches Löschen verknüpfter Daten in einer Datenbank verhindern.

      In bestimmten Situationen möchten Sie jedoch alle Einträge, die mit einem bestimmten Eintrag verbunden sind, aus den verschiedenen verknüpften Tabellen löschen. In diesem Fall verwenden Sie den AFTER DELETE-Trigger, den Sie im nächsten Schritt testen.

      Schritt 7 — Erstellen eines After Delete-Triggers

      AFTER DELETE-Trigger werden aktiviert, sobald ein Eintrag erfolgreich gelöscht wurde. Ein Beispiel dafür, wie Sie einen AFTER DELETE-Trigger verwenden können, ist eine Situation, in der die Rabattstufe, die ein bestimmter Kunde erhält, durch die Anzahl der in einem definierten Zeitraum vorgenommenen Käufe bestimmt wird. Wenn einige der Einträge des Kunden aus der Tabelle sales gelöscht werden, müsste die Rabattstufe des Kunden herabgestuft werden.

      Ein weiteres Einsatzbeispiel für den AFTER DELETE-Trigger ist das Löschen verknüpfter Daten aus einer anderen Tabelle, sobald ein Eintrag aus einer Basistabelle gelöscht wird. Beispielsweise können Sie einen Trigger einrichten, der den Kundendatensatz löscht, wenn die Verkaufseinträge mit der verknüpften customer_id aus der Tabelle sales gelöscht werden. Führen Sie den folgenden Befehl aus, um Ihren Trigger zu erstellen:

      • DELIMITER //
      • CREATE TRIGGER delete_related_info
      • AFTER DELETE
      • ON sales
      • FOR EACH ROW
      • Delete from customers where customer_id=OLD.customer_id;//
      • DELIMITER ;

      Führen Sie als Nächstes Folgendes aus, um alle mit der customer_id 2 verknüpften Verkaufseinträge zu löschen:

      • Delete from sales where customer_id='2';

      Output

      Query OK, 1 row affected (0.00 sec)

      Überprüfen Sie nun, ob es Einträge für den Kunden aus der Tabelle sales gibt:

      • Select * from customers where customer_id='2';

      Sie erhalten eine Empty Set-Ausgabe, da der Kundendatensatz, der mit der customer_id 2 verknüpft ist, durch den Trigger gelöscht wurde:

      Output

      Empty set (0.00 sec)

      Sie haben nun alle verschiedenen Formen von Triggern verwendet, um bestimmte Funktionen auszuführen. Als Nächstes erfahren Sie, wie Sie einen Trigger aus der Datenbank entfernen können, wenn Sie ihn nicht mehr brauchen.

      Schritt 8 — Löschen von Triggern

      Ähnlich wie andere Datenbankobjekte können Sie auch Trigger mit dem Befehl DROP löschen. Die Syntax zum Löschen eines Triggers sieht folgendermaßen aus:

      Drop trigger [TRIGGER NAME];
      

      Um beispielsweise den letzten AFTER DELETE-Trigger zu löschen, den Sie erstellt haben, führen Sie den folgenden Befehl aus:

      • Drop trigger delete_related_info;

      Output

      Query OK, 0 rows affected (0.00 sec)

      Sie müssen Trigger löschen, wenn Sie deren Struktur neu erstellen möchten. In diesem Fall können Sie den Trigger entfernen und mit den verschiedenen Triggerbefehlen einen neuen Trigger definieren.

      Zusammenfassung

      In diesem Tutorial haben Sie die verschiedenen Arten von Triggern einer MySQL-Datenbank erstellt, verwendet und gelöscht. Unter Verwendung einer kundenbezogenen Datenbank haben Sie Trigger für verschiedene Einsatzfälle wie Datenvalidierung, Anwendung von Geschäftslogik, Überwachungsprotokollierung und Durchsetzung der referenziellen Integrität implementiert.

      Weitere Informationen zur Verwendung Ihrer MySQL-Datenbank finden Sie in folgenden Abschnitten:



      Source link