Detaillierte Erläuterung zum Erstellen und Aufrufen von gespeicherten MySQL-Prozeduren

Vorwort

Gespeicherte Prozedur:

Ein Satz programmierbarer Funktionen ist eine Reihe von SQL-Anweisungen zum Ausführen bestimmter Funktionen. Sie werden kompiliert, erstellt und in der Datenbank gespeichert. Benutzer können sie aufrufen und ausführen, indem sie den Namen der gespeicherten Prozedur angeben und (falls erforderlich) Parameter angeben.

Vorteile (warum gespeicherte Prozeduren verwenden?):

1. Kapseln Sie einige sich stark wiederholende Operationen in eine gespeicherte Prozedur, um die Aufrufe dieser SQLs zu vereinfachen

2. Stapelverarbeitung: SQL + Schleife, reduziert den Datenverkehr, auch als „Stapel ausführen“ bekannt

3. Einheitliche Schnittstelle zur Gewährleistung der Datensicherheit

Im Vergleich zur Oracle-Datenbank sind gespeicherte MySQL-Prozeduren relativ schwächer und werden weniger verwendet.

1. Erstellen und Aufrufen gespeicherter Prozeduren

• Eine gespeicherte Prozedur ist ein Codestück mit einem Namen, der zum Ausführen einer bestimmten Funktion verwendet wird.
• Die erstellte gespeicherte Prozedur wird im Datenwörterbuch der Datenbank gespeichert.

1. Erstellen Sie eine gespeicherte Prozedur

ERSTELLEN
    [DEFINER = { Benutzer | AKTUELLER_BENUTZER }]
 PROZEDUR sp_name ([proc_parameter[,...]])
    [Merkmal ...] Routinenkörper
proc_parameter:
    [ IN | OUT | INOUT ] Parametername Typ
Eigenschaften:
    KOMMENTAR 'Zeichenfolge'
  | SPRACHE SQL
  | [NICHT] DETERMINISTISCH
  | { ENTHÄLT SQL | KEIN SQL | LIEST SQL-DATEN | ÄNDERT SQL-DATEN }
  | SQL-SICHERHEIT { DEFINER | INVOKER }
Routinekörper:
  Gültige SQL-Routineanweisung
[Beginn_Bezeichnung:] BEGINNEN
  [Anweisungsliste]
    …
ENDE [Ende_Label]

#Erstellen Sie eine Datenbank und sichern Sie die Datentabelle für Beispielvorgänge

mysql> Datenbank db1 erstellen;
mysql> verwende db1;    
mysql> Tabelle PLAYERS erstellen als select * from TENNIS.PLAYERS;
mysql> Tabelle MATCHES erstellen als select * from TENNIS.MATCHES;

Beispiel: Erstellen Sie eine gespeicherte Prozedur, die alle Spiele löscht, an denen ein bestimmter Spieler teilgenommen hat

mysql> Trennzeichen $$ #Ändern Sie vorübergehend das Endsymbol der Anweisung von Semikolon in zwei $$ (kann angepasst werden)
mysql> PROZEDUR ERSTELLEN delete_matches(IN p_playerno INTEGER)
    -> BEGIN
    -> AUS SPIELEN LÖSCHEN
    -> WO Spielernummer = p_Spielernummer;
    -> ENDE$$
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)
mysql> Trennzeichen; #Stellt das Endsymbol der Anweisung auf ein Semikolon zurück

Analyse:

Gespeicherte Prozeduren sind standardmäßig der Standarddatenbank zugeordnet. Wenn Sie angeben möchten, dass eine gespeicherte Prozedur in einer bestimmten Datenbank erstellt werden soll, stellen Sie dem Prozedurnamen den Datenbanknamen voran.

Verwenden Sie beim Definieren einer Prozedur den Befehl DELIMITER $$, um das Anweisungsendesymbol vorübergehend von einem Semikolon in zwei $$ zu ändern, sodass die im Prozedurhauptteil verwendeten Semikolons direkt an den Server übergeben werden, ohne vom Client (z. B. MySQL) interpretiert zu werden.

2. Rufen Sie die gespeicherte Prozedur auf: call sp_name[(Parameter übergeben)];

mysql> wähle * aus ÜBEREINSTIMMUNGEN;
+---------+--------+----------+-----+------+
| SPIELNR. | TEAMNR. | SPIELERNR. | GEWONNEN | VERLOREN |
+---------+--------+----------+-----+------+
| 1 | 1 | 6 | 3 | 1 |
| 7 | 1 | 57 | 3 | 0 |
| 8 | 1 | 8 | 0 | 3 |
| 9 | 2 | 27 | 3 | 2 |
| 11 | 2 | 112 | 2 | 3 |
+---------+--------+----------+-----+------+
5 Zeilen im Satz (0,00 Sek.)
mysql> rufe delete_matches(57) auf;
Abfrage OK, 1 Zeile betroffen (0,03 Sek.)
mysql> wähle * aus ÜBEREINSTIMMUNGEN;
+---------+--------+----------+-----+------+
| SPIELNR. | TEAMNR. | SPIELERNR. | GEWONNEN | VERLOREN |
+---------+--------+----------+-----+------+
| 1 | 1 | 6 | 3 | 1 |
| 8 | 1 | 8 | 0 | 3 |
| 9 | 2 | 27 | 3 | 2 |
| 11 | 2 | 112 | 2 | 3 |
+---------+--------+----------+-----+------+
4 Zeilen im Satz (0,00 Sek.)

Analyse:

Die Variable p_playerno, die als Parameter übergeben werden muss, wird in der gespeicherten Prozedur festgelegt. Wenn die gespeicherte Prozedur aufgerufen wird, wird p_playerno durch Parameterübergabe 57 zugewiesen, und dann wird die SQL-Operation in der gespeicherten Prozedur ausgeführt.

3. Hauptteil der gespeicherten Prozedur

• Der Hauptteil der gespeicherten Prozedur enthält Anweisungen, die beim Aufruf der Prozedur ausgeführt werden müssen, z. B. DML- und DDL-Anweisungen, if-then-else- und while-do-Anweisungen, Deklarationsanweisungen zum Deklarieren von Variablen usw.
• Format des Prozedurkörpers: beginnt mit begin und endet mit end (kann verschachtelt werden)

BEGINNEN
  BEGINNEN
    BEGINNEN
      aussagen; 
    ENDE
  ENDE
ENDE

Hinweis : Jeder verschachtelte Block und jede Anweisung darin muss mit einem Semikolon enden. Der Begin-End-Block (auch zusammengesetzte Anweisung genannt), der das Ende des Prozedurkörpers angibt, erfordert kein Semikolon.

4. Beschriften Sie die Anweisungsblöcke

[Beginn_Bezeichnung:] BEGINNEN
  [Anweisungsliste]
ENDE [Ende_Label]

Zum Beispiel:

label1: BEGIN
  label2: BEGIN
    label3: BEGIN
      aussagen; 
    ENDE Label3;
  ENDE Label2;
ENDE label1

Tags haben zwei Funktionen:

• Verbessern Sie die Lesbarkeit des Codes
• In einigen Anweisungen (z. B. Leave- und Iterate-Anweisungen) sind Beschriftungen erforderlich.

2. Parameter gespeicherter Prozeduren

Eine gespeicherte Prozedur kann null oder mehr Parameter haben, die in der Definition der gespeicherten Prozedur verwendet werden.

3 Parametertypen:

• IN-Eingabeparameter: Gibt an, dass der Aufrufer der Prozedur einen Wert übergibt (der übergebene Wert kann ein Literal oder eine Variable sein).
• OUT-Ausgabeparameter: gibt an, dass die Prozedur einen Wert an den Aufrufer übergibt (kann mehrere Werte zurückgeben) (der Ausgabewert kann nur eine Variable sein)
• INOUT-Eingabe- und Ausgabeparameter: Gibt an, dass der Aufrufer einen Wert an die Prozedur übergibt und die Prozedur einen Wert an den Aufrufer übergibt (der Wert kann nur eine Variable sein).

1. in Eingabeparametern

mysql> Trennzeichen $$
mysql> Prozedur in_param erstellen (in p_in int)
    -> beginnen
    -> wähle p_in;
    -> setze p_in=2;
    -> wähle P_in;
    -> Ende$$
mysql> Trennzeichen;
mysql> setze @p_in=1;
mysql> rufe in_param(@p_in) auf;
+------+
| p_ein |
+------+
| 1 |
+------+
+------+
| P_ein |
+------+
| 2 |
+------+
mysql> wähle @p_in;
+----------+
| @p_in |
+----------+
| 1 |
+----------+

#Aus dem Obigen können wir ersehen, dass p_in in der gespeicherten Prozedur geändert wird, dies hat jedoch keinen Einfluss auf den Wert von @p_id, da ersteres eine lokale Variable und letzteres eine globale Variable ist.

2. out-Ausgabeparameter

mysql> Trennzeichen //
mysql> Prozedur out_param erstellen (out p_out int)
    -> beginnen
    -> wähle p_out;
    -> setze p_out=2;
    -> wähle p_out;
    -> Ende
    -> //
mysql> Trennzeichen;
mysql> setze @p_out=1;
mysql> rufe out_param(@p_out) auf;
+----------+
| p_aus |
+----------+
| NULL |
+----------+
  #Da out Parameter an den Anrufer ausgibt und keine Eingabeparameter empfängt, ist p_out in der gespeicherten Prozedur null
+----------+
| p_aus |
+----------+
| 2 |
+----------+
mysql> wähle @p_out;
+--------+
| @p_out |
+--------+
| 2 |
+--------+
  #Rufen Sie die gespeicherte Prozedur out_param auf, geben Sie die Parameter aus und ändern Sie den Wert der Variablen p_out

3. Inout-Eingabeparameter

mysql> Trennzeichen $$
mysql> Prozedur inout_param erstellen(inout p_inout int)
    -> beginnen
    -> p_inout auswählen;
    -> setze p_inout=2;
    -> p_inout auswählen;
    -> Ende
    -> $$
mysql> Trennzeichen;
mysql> setze @p_inout=1;
mysql> rufe inout_param(@p_inout) auf;
+---------+
| p_eingang |
+---------+
| 1 |
+---------+
+---------+
| p_eingang |
+---------+
| 2 |
+---------+
mysql> wähle @p_inout;
+----------+
| @p_inout |
+----------+
| 2 |
+----------+

#Die gespeicherte Prozedur inout_param wurde aufgerufen, die Eingabeparameter wurden akzeptiert und die Parameter wurden auch ausgegeben, wobei die Variablen geändert wurden

Beachten:

1 Wenn die Prozedur keine Parameter hat, müssen Sie nach dem Prozedurnamen auch Klammern schreiben.

Beispiel : CREATE PROCEDURE sp_name ([proc_parameter[,...]]) …

2. Stellen Sie sicher, dass der Parametername nicht mit dem Spaltennamen übereinstimmt. Andernfalls wird der Parametername im Prozedurkörper als Spaltenname behandelt.

Vorschlag für einen Wandriss:

• Verwendung von Eingabewerten in Parametern;
• Der Rückgabewert verwendet den Out-Parameter;
• Versuchen Sie, Ein-/Ausgabeparameter so wenig wie möglich zu verwenden.

Zusammenfassen

Dieser Artikel endet hier. Ich hoffe, er kann Ihnen helfen. Ich hoffe auch, dass Sie mehr Inhalt auf 123WORDPRESS.COM lesen können!