Bei der Arbeit mit relationalen Datenbanken werden \u00fcblicherweise SQL-Anweisungen (Structured Query Language) verwendet, um Daten direkt aus dem Anwendungscode abzurufen oder zu bearbeiten, beispielsweise SELECT, INSERT, UPDATE oder DELETE. Diese Anweisungen greifen direkt auf die zugrunde liegenden Datenbanktabellen zu und ver\u00e4ndern diese. Werden dieselben Anweisungen oder Anweisungsgruppen in mehreren Anwendungen verwendet, die auf dieselbe Datenbank zugreifen, werden sie h\u00e4ufig in den einzelnen Anwendungen wiederholt.<\/p>\n
MySQL unterst\u00fctzt, wie viele andere relationale Datenbankmanagementsysteme, die Verwendung von gespeicherten Prozeduren. Gespeicherte Prozeduren helfen dabei, eine oder mehrere SQL-Anweisungen zur Wiederverwendung unter einem gemeinsamen Namen zu gruppieren und die allgemeine Gesch\u00e4ftslogik in der Datenbank selbst zu kapseln. Eine solche Prozedur kann von einer Anwendung aufgerufen werden, die auf die Datenbank zugreift, um Daten konsistent abzurufen oder zu bearbeiten.<\/p>\n
Mithilfe von gespeicherten Prozeduren k\u00f6nnen Sie wiederverwendbare Routinen f\u00fcr h\u00e4ufige Aufgaben erstellen, die in mehreren Anwendungen eingesetzt werden k\u00f6nnen, Daten validieren oder eine zus\u00e4tzliche Ebene der Datenzugriffssicherheit bereitstellen, indem Sie Datenbankbenutzer daran hindern, direkt auf zugrunde liegende Tabellen zuzugreifen und beliebige Abfragen auszuf\u00fchren.<\/p>\n
In diesem Tutorial lernen Sie, was gespeicherte Prozeduren sind und wie man einfache gespeicherte Prozeduren erstellt, die Daten zur\u00fcckgeben und Eingabe- und Ausgabeparameter verwenden.<\/p>\n
Um dieser Anleitung folgen zu k\u00f6nnen, ben\u00f6tigen Sie einen Computer mit einem SQL-basierten relationalen Datenbankmanagementsystem (RDBMS). Die Anweisungen und Beispiele in dieser Anleitung wurden in der folgenden Umgebung validiert:<\/p>\n
Hinweis: Viele relationale Datenbankmanagementsysteme (RDBMS) verwenden ihre eigene SQL-Implementierung, und die Syntax f\u00fcr gespeicherte Prozeduren ist nicht Teil des offiziellen SQL-Standards. Obwohl die in diesem Tutorial erw\u00e4hnten Befehle auch in anderen RDBMS funktionieren k\u00f6nnen, sind gespeicherte Prozeduren datenbankspezifisch. Daher k\u00f6nnen Syntax und Ausgabe abweichen, wenn Sie sie auf einem anderen System als MySQL testen.<\/span><\/p>\n Sie ben\u00f6tigen au\u00dferdem eine leere Datenbank, in der Sie mithilfe von gespeicherten Prozeduren Tabellen erstellen k\u00f6nnen. Wir empfehlen Ihnen, die folgenden Abschnitte zu lesen, um detaillierte Informationen zum Verbinden mit einem MySQL-Server und zum Erstellen der in den Beispielen dieses Leitfadens verwendeten Testdatenbank zu erhalten.<\/p>\n In diesem Abschnitt stellen Sie eine Verbindung zum MySQL-Server her und erstellen eine Beispieldatenbank, damit Sie die Beispiele in diesem Leitfaden verwenden k\u00f6nnen.<\/p>\n In dieser Anleitung verwenden Sie eine fiktive Autosammlung. Sie speichern Details zu den Autos, die Sie aktuell besitzen, einschlie\u00dflich Marke, Modell, Baujahr und Wert.<\/p>\n Wenn Ihr SQL-Datenbanksystem auf einem Remote-Server l\u00e4uft, stellen Sie eine SSH-Verbindung von Ihrem lokalen Rechner zu Ihrem Server her:<\/p>\n \u00d6ffnen Sie anschlie\u00dfend die MySQL-Server-Eingabeaufforderung und ersetzen Sie \u201eSami\u201c durch Ihren MySQL-Benutzernamen:<\/p>\n Erstellen Sie eine Datenbank namens Prozeduren:<\/p>\n Wenn die Datenbank erfolgreich erstellt wurde, erhalten Sie folgende Ausgabe:<\/p>\n Um die Prozedurendatenbank auszuw\u00e4hlen, f\u00fchren Sie die folgende USE-Anweisung aus:<\/p>\n Sie erhalten folgende Ausgabe:<\/p>\n Sobald Sie eine Datenbank ausgew\u00e4hlt haben, k\u00f6nnen Sie darin Instanztabellen erstellen. Die Tabelle \u201eMaschinen\u201c enth\u00e4lt vereinfachte Daten \u00fcber die Maschinen in der Datenbank. Sie enth\u00e4lt die folgenden Spalten:<\/p>\n Erstellen Sie die Beispieltabelle mit folgendem Befehl:<\/p>\n Wenn die folgende Ausgabe gedruckt wird, wurde die Tabelle erstellt:<\/p>\n Laden Sie anschlie\u00dfend die Tabelle \u201eCars\u201c mit Beispieldaten, indem Sie die folgende INSERT INTO-Operation ausf\u00fchren:<\/p>\n Die Operation INSERT INTO f\u00fcgt der Tabelle zehn Beispiel-Sportwagen hinzu, f\u00fcnf Porsche-Modelle und f\u00fcnf Ferrari-Modelle. Die folgende Ausgabe zeigt, dass alle f\u00fcnf Zeilen hinzugef\u00fcgt wurden:<\/p>\n Damit sind Sie bereit, dem Rest der Anleitung zu folgen und mit der Verwendung von gespeicherten Prozeduren in SQL zu beginnen.<\/p>\n Gespeicherte Prozeduren in MySQL und vielen anderen relationalen Datenbanksystemen werden als Objekte bezeichnet. Sie enthalten eine oder mehrere Anweisungen, die beim Aufruf durch die Datenbank nacheinander ausgef\u00fchrt werden. Im einfachsten Fall kann eine gespeicherte Prozedur einen h\u00e4ufig verwendeten Ausdruck in einer wiederverwendbaren Routine speichern, beispielsweise zum Abrufen von Daten aus einer Datenbank mithilfe h\u00e4ufig verwendeter Filter. So l\u00e4sst sich beispielsweise eine gespeicherte Prozedur erstellen, um die Kunden eines Online-Shops abzurufen, die in den letzten Monaten bestellt haben. In komplexen Szenarien k\u00f6nnen gespeicherte Prozeduren umfangreiche Programme repr\u00e4sentieren, die komplexe Gesch\u00e4ftslogik f\u00fcr leistungsstarke Anwendungen beschreiben.<\/p>\n Die Anweisungen in einer gespeicherten Prozedur k\u00f6nnen g\u00e4ngige SQL-Anweisungen wie SELECT- oder INSERT-Abfragen enthalten, die Daten zur\u00fcckgeben oder bearbeiten. Dar\u00fcber hinaus k\u00f6nnen gespeicherte Prozeduren Folgendes verwenden:<\/p>\n Hinweis: Die umfangreiche Syntax von MySQL erm\u00f6glicht das Schreiben leistungsstarker Programme und die L\u00f6sung komplexer Probleme mithilfe von gespeicherten Prozeduren. Diese Anleitung behandelt lediglich die grundlegende Verwendung gespeicherter Prozeduren mit SQL-Anweisungen im Prozedurrumpf sowie Eingabe- und Ausgabeparametern. Bedingte Codeausf\u00fchrung, die Verwendung von Variablen, Schleifen und benutzerdefinierte Fehlerbehandlung werden in dieser Anleitung nicht behandelt. Wir empfehlen Ihnen, sich in der offiziellen MySQL-Dokumentation ausf\u00fchrlicher \u00fcber gespeicherte Prozeduren zu informieren.<\/span><\/p>\n <\/p>\n Wird die Prozedur \u00fcber ihren Namen aufgerufen, f\u00fchrt die Datenbank-Engine sie wie definiert, Anweisung f\u00fcr Anweisung aus.<\/p>\n Der Datenbankbenutzer muss \u00fcber die entsprechenden Berechtigungen verf\u00fcgen, um die jeweilige Prozedur auszuf\u00fchren. Diese Berechtigungsanforderung stellt eine zus\u00e4tzliche Sicherheitsebene dar, die den direkten Zugriff auf die Datenbank verhindert, gleichzeitig aber den Benutzern den Zugriff auf einzelne, sicher ausf\u00fchrbare Prozeduren erm\u00f6glicht.<\/p>\n Gespeicherte Prozeduren werden direkt auf dem Datenbankserver ausgef\u00fchrt, f\u00fchren alle Berechnungen lokal durch und geben die Ergebnisse erst nach Abschluss an den aufrufenden Benutzer zur\u00fcck.<\/p>\n Wenn Sie das Verhalten einer Prozedur \u00e4ndern m\u00f6chten, k\u00f6nnen Sie die Prozedur in der Datenbank aktualisieren. Anwendungen, die diese Prozedur verwenden, erhalten dann automatisch die neue Version. Alle Benutzer k\u00f6nnen den neuen Prozedurcode sofort nutzen, ohne ihre Anwendungen anpassen zu m\u00fcssen.<\/p>\n Hier ist die allgemeine Struktur des SQL-Codes, der zum Erstellen einer gespeicherten Prozedur verwendet wird:<\/p>\n Die erste und letzte Anweisung in diesem Code-Snippet lauten `DELIMITER \/\/` und `DELIMITER ;`. MySQL verwendet \u00fcblicherweise das Semikolon (;), um Anweisungen zu trennen und deren Anfang und Ende zu kennzeichnen. Werden mehrere Befehle in der MySQL-Konsole durch Semikolons getrennt ausgef\u00fchrt, werden sie als separate Befehle behandelt und nacheinander unabh\u00e4ngig voneinander ausgef\u00fchrt. Eine gespeicherte Prozedur kann jedoch mehrere Befehle enthalten, die beim Aufruf sequenziell ausgef\u00fchrt werden. Dies f\u00fchrt zu einem Problem, wenn Sie MySQL anweisen m\u00f6chten, eine neue Prozedur zu erstellen. Die Datenbank-Engine erkennt das Semikolon im Rumpf der gespeicherten Prozedur und geht f\u00e4lschlicherweise davon aus, dass die Ausf\u00fchrung des Befehls beendet werden soll. In diesem Fall handelt es sich bei dem betreffenden Befehl um den gesamten Code zur Prozedurerstellung und nicht um eine einzelne Anweisung innerhalb der Prozedur selbst. Daher interpretiert MySQL Ihre Absicht falsch.<\/p>\n Um diese Einschr\u00e4nkung zu umgehen, verwenden Sie die DELIMITER-Anweisung, um das Trennzeichen f\u00fcr die Dauer des CREATE PROCEDURE-Aufrufs vor\u00fcbergehend von ; auf \/\/ zu \u00e4ndern. Anschlie\u00dfend werden alle Semikolons im Rumpf der gespeicherten Prozedur unver\u00e4ndert an den Server gesendet. Nach Abschluss der gesamten Prozedur wird das Trennzeichen mit dem letzten DELIMITER ; wieder auf ; ge\u00e4ndert.<\/p>\n Der Kern des Codes zum Erstellen einer neuen Prozedur ist der Aufruf `CREATE PROCEDURE`, gefolgt vom Prozedurnamen: `procedure_name` im Beispiel. Auf den Prozedurnamen folgt optional eine Liste der Parameter, die die Prozedur akzeptiert. Der letzte Teil ist der Prozedurrumpf, der von `BEGIN`- und `END`-Anweisungen umschlossen wird. Innerhalb des Prozedurcodes befindet sich der Code, der eine SQL-Anweisung, wie beispielsweise eine `SELECT`-Abfrage, oder komplexeren Code enthalten kann.<\/p>\n Der END-Befehl endet mit \/\/, einem tempor\u00e4ren Trennzeichen, anstelle eines regul\u00e4ren Semikolons.<\/p>\n Im n\u00e4chsten Abschnitt erstellen Sie eine einfache parameterlose gespeicherte Prozedur, die eine Abfrage kapselt.<\/p>\n In diesem Abschnitt erstellen Sie Ihre erste gespeicherte Prozedur, die eine SQL-SELECT-Anweisung enth\u00e4lt, um eine Liste der Fahrzeuge, die dem Benutzer geh\u00f6ren, nach Marke und Wert in absteigender Reihenfolge zur\u00fcckzugeben.<\/p>\n Beginnen Sie mit der Ausf\u00fchrung der SELECT-Anweisung, die Sie verwenden m\u00f6chten:<\/p>\n Die Datenbank gibt eine Liste von Autos aus der Tabelle \u201eCars\u201c zur\u00fcck, zuerst nach Marke und dann innerhalb einer Marke nach Wert in absteigender Reihenfolge:<\/p>\n Der wertvollste Ferrari steht an der Spitze der Liste, der wertloseste Porsche am Ende.<\/p>\n Angenommen, diese Abfrage wird wiederholt in mehreren Anwendungen oder von mehreren Benutzern verwendet, und Sie m\u00f6chten sicherstellen, dass alle dieselbe Methode zum Sortieren der Ergebnisse verwenden. Dazu m\u00f6chten Sie eine gespeicherte Prozedur erstellen, die diesen Ausdruck unter einer wiederverwendbaren benannten Prozedur speichert.<\/p>\n Um diese gespeicherte Prozedur zu erstellen, f\u00fchren Sie den folgenden Codeausschnitt aus:<\/p>\n Wie im vorherigen Abschnitt erl\u00e4utert, weisen die erste und letzte Anweisung (DELIMITER \/\/ und DELIMITER \ud83d\ude09) MySQL an, das Semikolon als Anweisungstrennzeichen w\u00e4hrend der gesamten Prozedurerstellung zu ignorieren.<\/p>\n Auf die SQL-Anweisung CREATE PROCEDURE folgt der Prozedurname get_all_cars, den Sie so definieren k\u00f6nnen, dass er die Funktion der Prozedur bestm\u00f6glich beschreibt. Nach dem Prozedurnamen steht ein Klammerpaar (), in dem Sie Parameter hinzuf\u00fcgen k\u00f6nnen. In diesem Beispiel verwendet die Prozedur keine Parameter, daher sind die Klammern leer. Zwischen den Anweisungen BEGIN und END, die den Anfang und das Ende des Prozedurcodeblocks definieren, wird die zuvor verwendete SELECT-Anweisung unver\u00e4ndert wiedergegeben.<\/p>\n Die Datenbank wird mit einer Erfolgsmeldung antworten:<\/p>\n Die Prozedur get_all_cars ist nun in der Datenbank gespeichert und f\u00fchrt beim Aufruf die gespeicherte Anweisung unver\u00e4ndert aus.<\/p>\n Um eine gespeicherte Prozedur auszuf\u00fchren, verwenden Sie den SQL-Befehl CALL gefolgt vom Prozedurnamen. Versuchen Sie, die neu erstellte Prozedur wie folgt auszuf\u00fchren:<\/p>\n Der Prozedurname \u201eget_all_cars\u201c gen\u00fcgt, um die Prozedur zu verwenden. Sie m\u00fcssen keinen Teil der zuvor verwendeten SELECT-Anweisung mehr manuell eingeben. Die Datenbank verarbeitet die Ergebnisse genau so, wie sie die SELECT-Anweisung ausgibt.<\/p>\n Sie haben nun erfolgreich eine gespeicherte Prozedur ohne Parameter erstellt, die alle Autos aus der Tabelle \u201eCars\u201c in einer bestimmten Reihenfolge zur\u00fcckgibt. Sie k\u00f6nnen diese Methode in verschiedenen Anwendungen verwenden.<\/p>\n Im n\u00e4chsten Abschnitt erstellen Sie eine Prozedur, die Parameter akzeptiert, um das Verhalten der Prozedur in Abh\u00e4ngigkeit von der Benutzereingabe zu \u00e4ndern.<\/p>\n In diesem Abschnitt f\u00fcgen Sie der Definition der gespeicherten Prozedur Eingabeparameter hinzu, damit Benutzer, die die Prozedur ausf\u00fchren, Daten an sie \u00fcbergeben k\u00f6nnen. Beispielsweise k\u00f6nnen Benutzer Abfragefilter angeben.<\/p>\n Die bisherige gespeicherte Prozedur `get_all_cars` ruft immer alle Autos aus der Tabelle `cars` ab. Wir erstellen nun eine weitere Prozedur, die Autos eines bestimmten Baujahrs findet. Dazu definieren wir in der Prozedurdefinition einen Parameter namens `get_all_cars`.<\/p>\n F\u00fchren Sie folgenden Code aus:<\/p>\n Im Vergleich zum vorherigen Abschnitt gibt es einige \u00c4nderungen am Code zur Prozedurerstellung.<\/p>\n Zun\u00e4chst einmal lautet der Name get_cars_by_year, was die Methode beschreibt: Autos anhand ihres Herstellungsjahres abrufen.<\/p>\n Die vorherigen leeren Klammern enthalten nun eine Parameterdefinition: `IN year_filter int`. Das Schl\u00fcsselwort `IN` teilt der Datenbank mit, dass der Parameter vom aufrufenden Benutzer an die Prozedur \u00fcbergeben wird. `year_filter` ist ein beliebiger Name f\u00fcr den Parameter. Sie verwenden ihn, um im Prozedurcode auf den Parameter zu verweisen. `int` ist der Datentyp. In diesem Fall wird das Herstellungsjahr als numerischer Wert angegeben.<\/p>\n Der Parameter year_filter, der nach dem Prozedurnamen definiert ist, erscheint in der SELECT-Anweisung in der WHERE year = year_filter-Klausel und filtert die Tabelle der Autos nach ihrem Herstellungsjahr.<\/p>\n Die Datenbank wird erneut mit einer Erfolgsmeldung antworten:<\/p>\n Versuchen Sie, die Prozedur wie zuvor ohne Parameter auszuf\u00fchren:<\/p>\n Die MySQL-Datenbank gibt eine Fehlermeldung zur\u00fcck:<\/p>\n Dieses Mal erwartet die gespeicherte Prozedur einen Parameter, es wurde jedoch keiner angegeben. Um eine gespeicherte Prozedur mit Parametern aufzurufen, k\u00f6nnen Sie die Parameterwerte in Klammern in der von der Prozedur erwarteten Reihenfolge angeben. Um im Jahr 2017 hergestellte Fahrzeuge abzurufen, f\u00fchren Sie Folgendes aus:<\/p>\n Die aufgerufene Prozedur wird nun korrekt ausgef\u00fchrt und gibt die Liste der Autos f\u00fcr dieses Jahr zur\u00fcck:<\/p>\n In diesem Beispiel haben Sie gelernt, wie man Eingabeparameter an gespeicherte Prozeduren \u00fcbergibt und diese in Abfragen innerhalb einer Prozedur verwendet, um Filteroptionen bereitzustellen.<\/p>\n Im n\u00e4chsten Abschnitt verwenden Sie Ausgabeparameter, um Prozeduren zu erstellen, die bei einer einzigen Ausf\u00fchrung mehrere unterschiedliche Werte zur\u00fcckgeben.<\/p>\n In den beiden vorherigen Beispielen riefen die erstellten gespeicherten Prozeduren die SELECT-Anweisung auf, um ein Ergebnis-Set zur\u00fcckzugeben. In manchen F\u00e4llen ben\u00f6tigen Sie jedoch m\u00f6glicherweise eine gespeicherte Prozedur, die mehrere verschiedene Werte zusammen anstelle eines einzelnen Ergebnis-Sets f\u00fcr eine Abfrage zur\u00fcckgibt.<\/p>\n Angenommen, Sie m\u00f6chten eine Prozedur erstellen, die zusammenfassende Informationen \u00fcber Autos eines bestimmten Jahres liefert, einschlie\u00dflich der Anzahl der Autos in der Sammlung und ihres Marktwerts (Minimum, Maximum und Durchschnitt).<\/p>\n Hierf\u00fcr k\u00f6nnen Sie beim Erstellen einer neuen gespeicherten Prozedur OUT-Parameter verwenden. \u00c4hnlich wie IN-Parameter besitzen auch OUT-Parameter einen Namen und einen Datentyp. Anstatt jedoch Daten an die gespeicherte Prozedur zu \u00fcbergeben, k\u00f6nnen sie mit Daten aus der gespeicherten Prozedur bef\u00fcllt werden, um Werte an den aufrufenden Benutzer zur\u00fcckzugeben.<\/p>\n Erstellen Sie eine Prozedur get_car_stats_by_year, die zusammenfassende Daten f\u00fcr Autos aus einem bestimmten Produktionsjahr unter Verwendung von Ausgabeparametern zur\u00fcckgibt:<\/p>\n Dieses Mal gibt es neben dem IN-Parameter `year_filter`, der zum Filtern der Fahrzeuge nach Baujahr dient, vier OUT-Parameter im Klammerblock. Der Parameter `cars_number` ist vom Datentyp `int` und gibt die Anzahl der Fahrzeuge in der Menge zur\u00fcck. Die Parameter `min_value`, `avg_value` und `max_value` repr\u00e4sentieren den Marktwert und sind vom Datentyp `decimal(10, 2)` (\u00e4hnlich der Spalte `value` in der Tabelle `cars`). Sie liefern Informationen \u00fcber das g\u00fcnstigste und das teuerste Fahrzeug in der Menge sowie den Durchschnittspreis aller \u00fcbereinstimmenden Fahrzeuge.<\/p>\n Die SELECT-Anweisung sucht vier Werte aus der Tabelle cars mithilfe von SQL-Funktionen: COUNT, um die Gesamtzahl der Autos zu erhalten, und MIN, AVG und MAX, um den Minimal-, Durchschnitts- und Maximalwert aus der Spalte value zu erhalten.<\/p>\n Um der Datenbank mitzuteilen, dass die Ergebnisse dieser Abfrage in den Ausgabeparametern der gespeicherten Prozedur gespeichert werden sollen, wurde das neue Schl\u00fcsselwort INTO eingef\u00fchrt. Nach dem Schl\u00fcsselwort INTO werden die Namen der vier Prozedurparameter aufgelistet, die sich auf die abgerufenen Daten beziehen. Dadurch speichert MySQL den Wert von COUNT(*) im Parameter cars_number, das Ergebnis von MIN(value) im Parameter min_value usw.<\/p>\n Die Datenbank best\u00e4tigt die erfolgreiche Erstellung der Prozedur:<\/p>\n F\u00fchren Sie nun die neue Routine aus, indem Sie Folgendes tun:<\/p>\n Die vier neuen Parameter beginnen mit dem @-Symbol. Es handelt sich dabei um die Namen lokaler Variablen in der MySQL-Konsole, mit denen Sie Daten tempor\u00e4r speichern k\u00f6nnen. Wenn Sie diese an die erstellte gespeicherte Prozedur \u00fcbergeben, f\u00fcgt die Prozedur Werte in diese Variablen ein.<\/p>\n Die Datenbank wird mit Folgendem antworten:<\/p>\n Dies unterscheidet sich vom vorherigen Verhalten, bei dem die Ergebnisse sofort auf dem Bildschirm angezeigt wurden. Der Grund daf\u00fcr ist, dass die Ergebnisse der gespeicherten Prozedur in Ausgabeparametern gespeichert und nicht als Abfrageergebnisse zur\u00fcckgegeben werden. Um auf die Ergebnisse zuzugreifen, k\u00f6nnen Sie sie direkt in der MySQL-Shell wie folgt ausw\u00e4hlen:<\/p>\n Mit dieser Abfrage w\u00e4hlen Sie Werte aus lokalen Variablen aus, anstatt die Prozedur erneut aufzurufen. Die gespeicherte Prozedur speichert ihre Ergebnisse in diesen Variablen, und die Daten stehen bis zum Beenden der Shell zur Verf\u00fcgung.<\/p>\n Hinweis: Weitere Informationen zur Verwendung benutzerdefinierter Variablen in MySQL finden Sie im Abschnitt \u201eBenutzerdefinierte Variablen\u201c der Dokumentation. Bei der Anwendungsentwicklung variiert der Zugriff auf Daten, die von gespeicherten Prozeduren zur\u00fcckgegeben werden, je nach Programmiersprache und Framework. Im Zweifelsfall konsultieren Sie die Dokumentation Ihrer gew\u00e4hlten Sprache und Ihres Frameworks.<\/span><\/p>\n Die Ausgabe zeigt die Werte der Abfragevariablen an:<\/p>\n Die Werte entsprechen der Anzahl der im Jahr 2017 produzierten Autos sowie dem minimalen, durchschnittlichen und maximalen Marktwert der Autos aus diesem Produktionsjahr.<\/p>\n In diesem Beispiel haben Sie gelernt, wie Sie Ausgabeparameter verwenden, um innerhalb einer gespeicherten Prozedur mehrere unterschiedliche Werte zur sp\u00e4teren Verwendung zur\u00fcckzugeben. Im n\u00e4chsten Abschnitt erfahren Sie, wie Sie erstellte Prozeduren l\u00f6schen.<\/p>\n In diesem Abschnitt l\u00f6schen Sie die gespeicherten Prozeduren in der Datenbank.<\/p>\n Manchmal wird eine erstellte Prozedur nicht mehr ben\u00f6tigt. In anderen F\u00e4llen m\u00f6chten Sie m\u00f6glicherweise die Funktionsweise der Prozedur \u00e4ndern. MySQL erlaubt es nicht, die Definition einer Prozedur nach ihrer Erstellung zu \u00e4ndern. Daher bleibt Ihnen nur die M\u00f6glichkeit, die Prozedur zun\u00e4chst zu l\u00f6schen und sie anschlie\u00dfend mit den gew\u00fcnschten \u00c4nderungen neu zu erstellen.<\/p>\n Lassen wir die letzte Prozedur, get_car_stats_by_year, weg. Dazu k\u00f6nnen Sie die Anweisung DROP PROCEDURE verwenden:<\/p>\n Die Datenbank best\u00e4tigt das erfolgreiche L\u00f6schen des Vorgangs mit einer Erfolgsmeldung:<\/p>\n Sie k\u00f6nnen \u00fcberpr\u00fcfen, ob die Prozedur gel\u00f6scht wurde, indem Sie versuchen, sie aufzurufen. F\u00fchren Sie Folgendes aus:<\/p>\n Dieses Mal erhalten Sie eine Fehlermeldung, dass die Prozedur in der Datenbank nicht existiert:<\/p>\n In diesem Abschnitt haben Sie gelernt, wie man gespeicherte Prozeduren aus einer Datenbank l\u00f6scht.<\/p>\n Mit dieser Anleitung haben Sie gelernt, was gespeicherte Prozeduren sind und wie Sie diese in MySQL verwenden, um wiederverwendbare Anweisungen in benannten Prozeduren zu speichern und sp\u00e4ter auszuf\u00fchren. Sie haben gespeicherte Prozeduren ohne Parameter sowie Prozeduren mit Eingabe- und Ausgabeparametern erstellt, um diese flexibler zu gestalten.<\/p>","protected":false},"excerpt":{"rendered":"Einleitung Typischerweise werden bei der Arbeit mit relationalen Datenbanken SQL-Abfragen (Structured Query Language) verwendet\u2026","protected":false},"author":1,"featured_media":15989,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_yoast_wpseo_focuskw":"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 \u0631\u0648\u06cc\u0647 \u0647\u0627\u06cc \u0630\u062e\u06cc\u0631\u0647 \u0634\u062f\u0647 \u062f\u0631 MySQL","_yoast_wpseo_title":"","_yoast_wpseo_metadesc":"","_yoast_wpseo_canonical":"","_yoast_wpseo_opengraph-description":"","_yoast_wpseo_opengraph-image":"","_yoast_wpseo_twitter-description":"","_yoast_wpseo_twitter-image":"","_yoast_wpseo_focuskeywords":"","_yoast_wpseo_primary_category":"193","footnotes":""},"categories":[193,349],"tags":[403,391],"class_list":{"0":"post-15988","1":"post","2":"type-post","3":"status-publish","4":"format-standard","5":"has-post-thumbnail","7":"category-tutorials","8":"category-database","9":"tag-data-base","10":"tag-mysql"},"yoast_head":"\nVerbindung zu MySQL herstellen und eine Beispieldatenbank einrichten<\/h2>\n
ssh sammy@your_server_ip\r\n<\/code><\/pre>\n<\/div>\nmysql -u sammy -p\r\n<\/code><\/pre>\n<\/div>\nCREATE DATABASE procedures;\r\n<\/code><\/pre>\n<\/div>\nOutput\r\nQuery OK, 1 row affected (0.01 sec)<\/code><\/pre>\n<\/div>\nUSE procedures;\r\n<\/code><\/pre>\n<\/div>\nOutput\r\nDatabase changed<\/code><\/pre>\n<\/div>\n\n
CREATE TABLE cars (\r\nmake varchar(100),\r\nmodel varchar(100),\r\nyear int,\r\nvalue decimal(10, 2)\r\n);<\/code><\/pre>\n<\/div>\nOutput\r\nQuery OK, 0 rows affected (0.00 sec)<\/code><\/pre>\n<\/div>\nINSERT INTO cars\r\nVALUES\r\n('Porsche', '911 GT3', 2020, 169700),\r\n('Porsche', 'Cayman GT4', 2018, 118000),\r\n('Porsche', 'Panamera', 2022, 113200),\r\n('Porsche', 'Macan', 2019, 27400),\r\n('Porsche', '718 Boxster', 2017, 48880),\r\n('Ferrari', '488 GTB', 2015, 254750),\r\n('Ferrari', 'F8 Tributo', 2019, 375000),\r\n('Ferrari', 'SF90 Stradale', 2020, 627000),\r\n('Ferrari', '812 Superfast', 2017, 335300),\r\n('Ferrari', 'GTC4Lusso', 2016, 268000);<\/code><\/pre>\n<\/div>\nOutput\r\nQuery OK, 10 rows affected (0.00 sec)\r\nRecords: 10 Duplicates: 0 Warnings: 0<\/code><\/pre>\n<\/div>\nEinf\u00fchrung in gespeicherte Prozeduren<\/h2>\n
\n
DELIMITER \/\/\r\nCREATE PROCEDURE procedure_name(parameter_1, parameter_2, . . ., parameter_n)\r\nBEGIN\r\ninstruction_1;\r\ninstruction_2;\r\n. . .\r\ninstruction_n;\r\nEND \/\/\r\nDELIMITER ;<\/code><\/pre>\n<\/div>\nErstellen einer gespeicherten Prozedur ohne Parameter<\/h2>\n
SELECT * FROM cars ORDER BY make, value DESC;\r\n<\/code><\/pre>\n<\/div>\nOutput\r\n+---------+---------------+------+-----------+\r\n| make | model | year | value |\r\n+---------+---------------+------+-----------+\r\n| Ferrari | SF90 Stradale | 2020 | 627000.00 |\r\n| Ferrari | F8 Tributo | 2019 | 375000.00 |\r\n| Ferrari | 812 Superfast | 2017 | 335300.00 |\r\n| Ferrari | GTC4Lusso | 2016 | 268000.00 |\r\n| Ferrari | 488 GTB | 2015 | 254750.00 |\r\n| Porsche | 911 GT3 | 2020 | 169700.00 |\r\n| Porsche | Cayman GT4 | 2018 | 118000.00 |\r\n| Porsche | Panamera | 2022 | 113200.00 |\r\n| Porsche | 718 Boxster | 2017 | 48880.00 |\r\n| Porsche | Macan | 2019 | 27400.00 |\r\n+---------+---------------+------+-----------+\r\n10 rows in set (0.00 sec)<\/code><\/pre>\n<\/div>\nDELIMITER \/\/\r\nCREATE PROCEDURE get_all_cars()\r\nBEGIN\r\nSELECT * FROM cars ORDER BY make, value DESC;\r\nEND \/\/\r\nDELIMITER ;<\/code><\/pre>\n<\/div>\nOutput\r\nQuery OK, 0 rows affected (0.02 sec)<\/code><\/pre>\n<\/div>\nCALL get_all_cars;\r\n<\/code><\/pre>\n<\/div>\nOutput\r\n+---------+---------------+------+-----------+\r\n| make | model | year | value |\r\n+---------+---------------+------+-----------+\r\n| Ferrari | SF90 Stradale | 2020 | 627000.00 |\r\n| Ferrari | F8 Tributo | 2019 | 375000.00 |\r\n| Ferrari | 812 Superfast | 2017 | 335300.00 |\r\n| Ferrari | GTC4Lusso | 2016 | 268000.00 |\r\n| Ferrari | 488 GTB | 2015 | 254750.00 |\r\n| Porsche | 911 GT3 | 2020 | 169700.00 |\r\n| Porsche | Cayman GT4 | 2018 | 118000.00 |\r\n| Porsche | Panamera | 2022 | 113200.00 |\r\n| Porsche | 718 Boxster | 2017 | 48880.00 |\r\n| Porsche | Macan | 2019 | 27400.00 |\r\n+---------+---------------+------+-----------+\r\n10 rows in set (0.00 sec)\r\nQuery OK, 0 rows affected (0.00 sec)<\/code><\/pre>\n<\/div>\nErstellen einer gespeicherten Prozedur mit Eingabeparametern<\/h2>\n
DELIMITER \/\/\r\nCREATE PROCEDURE get_cars_by_year(\r\nIN year_filter int\r\n)\r\nBEGIN\r\nSELECT * FROM cars WHERE year = year_filter ORDER BY make, value DESC;\r\nEND \/\/\r\nDELIMITER ;<\/code><\/pre>\n<\/div>\nOutput\r\nQuery OK, 0 rows affected (0.02 sec)<\/code><\/pre>\n<\/div>\nCALL get_cars_by_year;\r\n<\/code><\/pre>\n<\/div>\nError message\r\nERROR 1318 (42000): Incorrect number of arguments for PROCEDURE procedures.get_cars_by_year; expected 1, got 0<\/code><\/pre>\n<\/div>\nCALL get_cars_by_year(2017);\r\n<\/code><\/pre>\n<\/div>\nOutput\r\n+---------+---------------+------+-----------+\r\n| make | model | year | value |\r\n+---------+---------------+------+-----------+\r\n| Ferrari | 812 Superfast | 2017 | 335300.00 |\r\n| Porsche | 718 Boxster | 2017 | 48880.00 |\r\n+---------+---------------+------+-----------+\r\n2 rows in set (0.00 sec)\r\nQuery OK, 0 rows affected (0.00 sec)<\/code><\/pre>\n<\/div>\nErstellen einer gespeicherten Prozedur mit Eingabe- und Ausgabeparametern<\/h2>\n
DELIMITER \/\/\r\nCREATE PROCEDURE get_car_stats_by_year(\r\nIN year_filter int,\r\nOUT cars_number int,\r\nOUT min_value decimal(10, 2),\r\nOUT avg_value decimal(10, 2),\r\nOUT max_value decimal(10, 2)\r\n)\r\nBEGIN\r\nSELECT COUNT(*), MIN(value), AVG(value), MAX(value)\r\nINTO cars_number, min_value, avg_value, max_value\r\nFROM cars\r\nWHERE year = year_filter ORDER BY make, value DESC;\r\nEND \/\/\r\nDELIMITER ;<\/code><\/pre>\n<\/div>\nOutput\r\nQuery OK, 0 rows affected (0.02 sec)<\/code><\/pre>\n<\/div>\nCALL get_car_stats_by_year(2017, @number, @min, @avg, @max);\r\n<\/code><\/pre>\n<\/div>\nOutput\r\nQuery OK, 1 row affected (0.00 sec)<\/code><\/pre>\n<\/div>\nSELECT @number, @min, @avg, @max;\r\n<\/code><\/pre>\n<\/div>\nOutput\r\n+---------+----------+-----------+-----------+\r\n| @number | @min | @avg | @max |\r\n+---------+----------+-----------+-----------+\r\n| 2 | 48880.00 | 192090.00 | 335300.00 |\r\n+---------+----------+-----------+-----------+\r\n1 row in set (0.00 sec)<\/code><\/pre>\n<\/div>\nGespeicherte Prozeduren l\u00f6schen<\/h2>\n
DROP PROCEDURE get_car_stats_by_year;\r\n<\/code><\/pre>\n<\/div>\nOutput\r\nQuery OK, 0 rows affected (0.02 sec)<\/code><\/pre>\n<\/div>\nCALL get_car_stats_by_year(2017, @number, @min, @avg, @max);\r\n<\/code><\/pre>\n<\/div>\nError message\r\nERROR 1305 (42000): PROCEDURE procedures.get_car_stats_by_year does not exist<\/code><\/pre>\n<\/div>\nErgebnis<\/h2>\n