Ausführliche Erläuterung der gespeicherten MySQL-Prozeduren (in, out, inout)

1. Einleitung

Es wird seit Version 5.0 unterstützt. Es handelt sich um eine Reihe von SQL-Anweisungen (Kapselung) zum Ausführen bestimmter Funktionen. Es ist schneller und effizienter als herkömmliches SQL.

Vorteile gespeicherter Prozeduren

1. Nach einmaliger Ausführung wird der generierte Binärcode im Puffer gespeichert (für die nächste Ausführung), um die Ausführungseffizienz zu verbessern

2. Eine Sammlung von SQL-Anweisungen plus Steueranweisungen, hochflexibel

3. Speichern Sie auf der Serverseite und reduzieren Sie die Netzwerklast, wenn der Client anruft

4. Kann wiederholt aufgerufen und jederzeit geändert werden, ohne den Clientaufruf zu beeinträchtigen

5. Alle Datenbankvorgänge können abgeschlossen und die Informationszugriffsrechte der Datenbank kontrolliert werden

Warum gespeicherte Prozeduren verwenden?

1. Reduzieren Sie die Netzwerklast; 2. Erhöhen Sie die Sicherheit

2. Erstellen Sie eine gespeicherte Prozedur

2.1 Erstellen eines Basisprozesses

Verwenden der Anweisung „create procedure“, um eine gespeicherte Prozedur zu erstellen

Der Hauptteil einer gespeicherten Prozedur wird als Prozedurkörper bezeichnet; er beginnt mit begin und endet mit end$$

#Deklarationsanweisungsabschlusszeichen, kann angepasst werden:
Trennzeichen $$
#Deklarieren Sie eine gespeicherte Prozedur. Erstellen Sie eine Prozedur. Name der gespeicherten Prozedur (im Parameternamen-Parametertyp).
beginnen
#Variable definieren, Variablennamen deklarieren, Variablentyp #Variablenwert zuweisen, Variablennamen festlegen = Wert SQL-Anweisung 1;
 SQL-Anweisung 2;
 ...
Ende$$
#Den ursprünglichen Anweisungsabschluss- und Trennzeichen wiederherstellen (mit Leerzeichen)

Beispiele:

mysql> Trennzeichen $$
mysql> Prozedurtext erstellen()
 -> beginnen
 -> wähle * aus stu.a_player;
 -> Ende $$
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
mysql> Trennzeichen;

Aufrufen einer gespeicherten Prozedur

Rufen Sie den Namen der gespeicherten Prozedur auf (tatsächliche Parameter);
mysql> Aufruftext;
+----+----------+-------+
| ID | Name | Punktzahl |
+----+----------+-------+
| 1 | zhangsan | 88 |
| 2 | lisi | 89 |
| 3 | wangwu | 67 |
| 4 | zhaoliu | 90 |
| 5 | xuli | 80 |
| 6 | keke | 75 |
+----+----------+-------+
6 Zeilen im Satz (0,00 Sek.)

Löschen einer gespeicherten Prozedur

mysql> Prozedurtext löschen;

2.2 Parameter gespeicherter Prozeduren

Die Parameter von MySQL-gespeicherten Prozeduren werden bei der Definition von gespeicherten Prozeduren verwendet. Es gibt drei Arten von Parametern: IN, OUT und INOUT. Die Formen sind wie folgt:

CREATEPROCEDURE Name der gespeicherten Prozedur ([[IN | OUT | INOUT ] Parametername Datentyp ...])

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).

Beispiel für die Parameterübergabe:

IN

mysql> erstelle Prozedur test1(in in_id int(2))
 -> beginnen
 -> wähle * aus stu.a_player, wobei id=in_id;
 -> Ende $$
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
mysql> Trennzeichen;

# Übergeben Sie 4 an die Variable in_id und führen Sie die Transaktion aus mysql> call test1(4); 
+----+---------+-------+
| ID | Name | Punktzahl |
+----+---------+-------+
| 4 | zhaoliu | 90 |
+----+---------+-------+
1 Zeile im Satz (0,00 Sek.)

# Übergeben Sie 6 an die Variable in_id und führen Sie die Transaktion aus mysql> call test1(6);
+----+------+-------+
| ID | Name | Punktzahl |
+----+------+-------+
| 6 | keke | 75 |
+----+------+-------+
1 Zeile im Satz (0,00 Sek.)

AUS

mysql> Trennzeichen $$
mysql> Prozedur test2 erstellen (out aa int) 
 -> beginnen
 -> wähle aa;
 -> setze aa=2;
 -> wähle aa;
 -> Ende $$
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
mysql> Trennzeichen;
#Übergeben Sie die Variable @aa an die Transaktion test2 mysql> call test2(@aa);
+------+
|
+------+
| NULL |
+------+
#out gibt Parameter an den Anrufer aus und empfängt keine Eingabeparameter, daher ist aa null
1 Zeile im Satz (0,00 Sek.)
+------+
|
+------+
| 2 |
+------+
Die Transaktion setzt die Variable aa auf 2 (global) und gibt dann 1 Zeile im Set aus (0,00 Sek.)
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
mysql> wähle @aa;
+------+
| @aa |
+------+
| 2 |
+------+
1 Zeile im Satz (0,00 Sek.)
#Abfragevariable außerhalb der Transaktion, wurde geändert

IN, OUT, INOUT-Vergleich

mysql> Trennzeichen //
mysql> Prozedur test3 erstellen (in num1 int, out num2 int, inout num3 int)
 -> beginnen
 -> wähle num1, num2, num3;
 -> setze Num1=10, Num2=20, Num3=30;
 -> wähle num1, num2, num3;
 -> Ende //
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
mysql> Trennzeichen;
mysql> rufe test3(@num1,@num2,@num3) auf;
+------+------+------+
| Zahl1 | Zahl2 | Zahl3 |
+------+------+------+
| 1 | NULL | 3 |
+------+------+------+
1 Zeile im Satz (0,00 Sek.)
+------+------+------+
| Zahl1 | Zahl2 | Zahl3 |
+------+------+------+
| 10 | 20 | 30 |
+------+------+------+
1 Zeile im Satz (0,00 Sek.)
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)

Die In- und Inout-Parameter übergeben den Wert der globalen Variable an die gespeicherte Prozedur, während der Out-Parameter den Wert der globalen Variable nicht an die gespeicherte Prozedur übergibt. Bei Verwendung einer gespeicherten Prozedur ändern sich die Parameterwerte in, out und inout.

mysql> wähle @num1,@num2,@num3;
+-------+-------+---------+
| @Nummer1 | @Nummer2 | @Nummer3 |
+-------+-------+---------+
| 1 | 20 | 30 |
+-------+-------+---------+
1 Zeile im Satz (0,00 Sek.)

Nach dem Aufruf der gespeicherten Prozedur wird festgestellt, dass der In-Parameter keine Änderungen am Wert der globalen Variablen bewirkt, während die Out- und Inout-Parameter nach dem Aufruf der gespeicherten Prozedur den Wert der globalen Variablen ändern und der von der gespeicherten Prozedur referenzierte Wert der globalen Variablen zugewiesen wird.

Der In-Parameterzuweisungstyp kann eine Variable oder ein fester Wert sein, während der Out- und Inout-Parameterzuweisungstyp eine Variable sein muss.

Zusammenfassen

Dies ist das Ende dieses Artikels über gespeicherte MySQL-Prozeduren (in, out, inout). Weitere Informationen zu gespeicherten MySQL-Prozeduren (in, out, inout) finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!