Opgeslagen MySQL-procedures maken en gebruiken

Opgeslagen procedures zijn door de gebruiker gedefinieerde SQL-instructies die worden opgeslagen in een MySQL-database en op aanvraag worden uitgevoerd om een specifieke databasebewerking uit te voeren. Deze vooraf gedefinieerde subroutines helpen bij het verplaatsen van de bedrijfslogica naar de database, wat een aantal voordelen biedt:

Retourreizen naar de databaseserver door een applicatie worden geminimaliseerd.
De onderhoudbaarheid van de code is verbeterd, aangezien verschillende applicaties de opgeslagen procedure kunnen delen.
De prestaties van de database zijn verbeterd, omdat opgeslagen procedures één keer worden gecompileerd en zeer snel en efficiënt worden uitgevoerd.

In deze handleiding zult u:

Leer de syntaxis voor het maken van opgeslagen procedures en declareer uw eerste procedure.
Voer de voorbeeldprocedure uit nadat u deze heeft gedeclareerd.
Leer hoe u een procedure kunt verwijderen wanneer u deze niet langer nodig heeft.

Voordat u begint

Zorg ervoor dat u over het volgende beschikt:

Als je dit nog niet hebt gedaan, maak dan een Linode-account en Compute Instance aan. Zie onze handleidingen Aan de slag met Linode en Een rekeninstantie maken.
Volg onze handleiding voor het instellen en beveiligen van een rekeninstantie om uw systeem bij te werken. Mogelijk wilt u ook de tijdzone instellen, uw hostnaam configureren, een beperkt gebruikersaccount maken en SSH-toegang versterken.
Een MySQL-server en client geïnstalleerd op de Linode-server. Installatiehandleidingen voor MySQL zijn beschikbaar voor verschillende distributies in onze MySQL-sectie.

Bereid de database voor

U begint met het maken van een voorbeelddatabase, tabel en gebruiker voor toegang tot de database. U vult de tabel ook met voorbeeldgegevens voor testdoeleinden.

De database, tabel en gebruiker maken

Log in op de MySQL-server:
```
 mysql -u root -p
```
U wordt gevraagd om het root-wachtwoord van uw MySQL-database in te voeren. Druk vervolgens op Enter om door te gaan.
Vervolgens ziet u een MySQL-prompt die lijkt op de onderstaande.
```
mysql >
```
Voer de onderstaande opdracht in om een test_db . te maken databank:
```
CREATE DATABASE test_db;
```
Uitgang:
```
Query OK, 1 row affected (0.01 sec)
```
Maak een databasegebruiker aan en verleen volledige toegang tot de test_db databank. Vervang PASSWORD met een complexe en unieke waarde die de richtlijnen voor MySQL-wachtwoorden volgt:
```
CREATE USER 'test_user'@'localhost' IDENTIFIED BY 'PASSWORD';
```
Uitgang:
```
Query OK, 1 row affected (0.01 sec)
```

Geef de test_user volledige privileges voor de test_db databank;

GRANT ALL PRIVILEGES ON test_db.* TO 'test_user'@'localhost';

Uitgang:

Query OK, 1 row affected (0.01 sec)

Spoelrechten:

FLUSH PRIVILEGES;

Uitgang:

Query OK, 0 rows affected (0.01 sec)

De database vullen

Schakel vervolgens over naar de test_db-database:
```
USE test_db;
```
Uitgang:
```
Database changed
```

Maak een products tabel om voorbeeldrecords op te slaan:

CREATE TABLE products(product_id BIGINT PRIMARY KEY, product_name VARCHAR(50), category_name VARCHAR(50) ) ENGINE=INNODB;

Uitgang:

Query OK, 0 rows affected (0.01 sec)

U kunt nu een aantal producten aan de producttabel toevoegen door de onderstaande commando's een voor een uit te voeren:

INSERT INTO products (product_id, product_name, category_name) VALUES ('1', 'GAMING KEYBOARD', 'COMPUTER ACCESSORIES');
INSERT INTO products (product_id, product_name, category_name) VALUES ('2', 'OPTICAL MOUSE', 'COMPUTER ACCESSORIES');
INSERT INTO products (product_id, product_name, category_name) VALUES ('3', 'MOUSE PAD', 'COMPUTER ACCESSORIES');
INSERT INTO products (product_id, product_name, category_name) VALUES ('4', 'STEREO SYSTEM', 'ELECTRONICS');
INSERT INTO products (product_id, product_name, category_name) VALUES ('5', '32 INCH TV', 'ELECTRONICS');
INSERT INTO products (product_id, product_name, category_name) VALUES ('6', 'DVB-T2 RECEIVER', 'ELECTRONICS');

U zou de onderstaande uitvoer moeten krijgen na het uitvoeren van elke Insert verklaring:

Query OK, 1 row affected (0.00 sec)

Volgende. bevestig of de voorbeeldproducten met succes in de database zijn ingevoerd door Select . uit te voeren onderstaande opdracht:

SELECT * FROM products;

Uw voorbeeldproducten moeten worden weergegeven zoals hieronder weergegeven:

+------------+-----------------+----------------------+
| product_id | product_name    | category_name        |
+------------+-----------------+----------------------+
|          1 | GAMING KEYBOARD | COMPUTER ACCESSORIES |
|          2 | OPTICAL MOUSE   | COMPUTER ACCESSORIES |
|          3 | MOUSE PAD       | COMPUTER ACCESSORIES |
|          4 | STEREO SYSTEM   | ELECTRONICS          |
|          5 | 32 INCH TV      | ELECTRONICS          |
|          6 | DVB-T2 RECEIVER | ELECTRONICS          |
+------------+-----------------+----------------------+
6 rows in set (0.00 sec)

Verlaat de MySQL-server.
```
QUIT;
```
Uitgang:
```
Bye!
```
Nadat u een test_db . heeft gemaakt database, products tabel, een test_user , en enkele voorbeeldproducten hebt toegevoegd, kunt u nu doorgaan met het maken van de eerste opgeslagen procedure.

Een opgeslagen procedure maken

Opgeslagen proceduresyntaxis

De basissyntaxis voor het maken van een opgeslagen procedure in de MySQL-database wordt hieronder weergegeven:

DELIMITER &&
CREATE PROCEDURE PROCEDURE_NAME (PARAMETER_1, PARAMETER_2, PARAMETER_N...)
BEGIN
[SQL STATEMENT]
END &&
DELIMITER ;

De DELIMITER && regel aan het begin vertelt MySQL-server om de volgende SQL-instructies als een enkele instructie te behandelen, in plaats van ze afzonderlijk uit te voeren. Nog een && is opgenomen op een latere regel om het einde van deze verklaring te markeren.
PROCEDURE_NAME is waar de naam van uw opgeslagen procedure wordt gedeclareerd.
De procedurenaam wordt gevolgd door een reeks haakjes, en deze omsluiten de parameters van uw procedure. Opgeslagen procedures ondersteunen door komma's gescheiden parameters en deze functie maakt ze flexibeler. Zie de sectie parameters voor meer details.
De BEGIN...END commando's omsluiten de SQL-instructie die u wilt laten uitvoeren door de opgeslagen procedure.
Op het einde, de instructie DELIMITER ; wordt opnieuw uitgegeven om het scheidingsteken terug te zetten naar de standaardwaarde van ;

Opgeslagen procedureparameters

Elke parameter voor een procedure heeft een type, naam en een gegevenstype, gescheiden door spaties:

PARAMETER_TYPE PARAMETER_NAME DATA_TYPE

Om bijvoorbeeld een parameter van het type IN . te maken , genaamd category , met de VARCHAR gegevenstype met een lengte van 50 tekens, gebruik deze syntaxis:

IN category VARCHAR(50)

MySQL ondersteunt drie soorten parameters:

IN :De waarde van de parameter moet worden opgegeven door de aanroepende client. Deze waarde kan niet worden gewijzigd door de opgeslagen procedure .

Als u bijvoorbeeld een MySQL-sessievariabele doorgeeft als een IN parameter toe aan een procedure, en de procedure wijzigt deze waarde in zijn instructies, uw sessievariabele blijft ongewijzigd nadat de procedure is afgesloten.
OUT :Dit type parameter wordt ook gespecificeerd door het oproepende programma, maar de waarde ervan kan worden gewijzigd door de opgeslagen procedure en opgehaald door het oproepende programma.

Merk op dat de opgeslagen procedure geen toegang heeft tot de initiële waarde van een variabele die wordt doorgegeven als een OUT parameter.
INOUT :Een parameter van dit type combineert het gedrag van IN en OUT parameters:
- De opgeslagen procedure kan de initiële waarde van de parameter lezen.
- De parameter kan worden gewijzigd tijdens de uitvoering van de opgeslagen procedure.
- De gewijzigde waarde kan worden teruggestuurd naar het aanroepende programma, als het aanroepende programma een variabele als parameter heeft doorgegeven.

Een voorbeeld van een opgeslagen procedure

Laten we, nadat we de basissyntaxis hebben begrepen, een eenvoudige opgeslagen procedure maken om producten op categorienaam te filteren. De categorienaam wordt geleverd als een IN parameter.

Log in op de MySQL-server met de test_user ’s inloggegevens die u hebt gemaakt bij het voorbereiden van de database:
```
 mysql -u test_user -p
```
Voer het wachtwoord in van de test_user en druk op Enter om door te gaan.
U krijgt een mysql > snel. Ga verder door de test_db . te selecteren :
```
 USE test_db;
```
Uitgang:
```
Database changed.
```

Voer vervolgens de onderstaande SQL-opdrachten in om een filter_by_category . te maken opgeslagen procedure:

 DELIMITER &&
 CREATE PROCEDURE filter_by_category (IN category VARCHAR(50))
 BEGIN
 SELECT * FROM products WHERE category_name=category;
 END &&

Uitgang:

Query OK, 0 rows affected (0.00 sec)

Wijzig de DELIMITER terug naar ;
```
DELIMITER ;
```
Als de code voor het maken van de opgeslagen procedure met succes is uitgevoerd, kunt u nu doorgaan met het uitvoeren van de opgeslagen procedure.

Een opgeslagen procedure uitvoeren

In deze stap noemen we de opgeslagen procedure die we hierboven hebben gemaakt. We zullen deze basissyntaxis volgen:

CALL PROCEDURE_NAME (COMMA-SEPARATED PARAMETER VALUES);

Om de filter_by_category uit te voeren opgeslagen procedure die we hierboven hebben gemaakt, voer de onderstaande opdracht in:

CALL filter_by_category('COMPUTER ACCESSORIES');

De opgeslagen procedure zou nu alle producten moeten uitvoeren in de COMPUTER ACCESSORIES categorie omdat we COMPUTER ACCESSORIES . hebben gespecificeerd als parameter:

+------------+-----------------+----------------------+
| product_id | product_name    | category_name        |
+------------+-----------------+----------------------+
|          1 | GAMING KEYBOARD | COMPUTER ACCESSORIES |
|          2 | OPTICAL MOUSE   | COMPUTER ACCESSORIES |
|          3 | MOUSE PAD       | COMPUTER ACCESSORIES |
+------------+-----------------+----------------------+
3 rows in set (0.00 sec)

Query OK, 0 rows affected (0.01 sec)

Op dezelfde manier kunt u een lijst van alle producten ophalen uit de ELECTRONICS categorie door het onderstaande commando uit te voeren.

CALL filter_by_category('ELECTRONICS') ;

Uitgang:

+------------+-----------------+---------------+
| product_id | product_name    | category_name |
+------------+-----------------+---------------+
|          4 | STEREO SYSTEM   | ELECTRONICS   |
|          5 | 32 INCH TV      | ELECTRONICS   |
|          6 | DVB-T2 RECEIVER | ELECTRONICS   |
+------------+-----------------+---------------+
3 rows in set (0.00 sec)

Query OK, 0 rows affected (0.01 sec)

Onze opgeslagen procedure werkte zoals we hadden verwacht. Vervolgens zullen we leren hoe we de opgeslagen procedures kunnen verwijderen als we niet langer willen dat ze opnieuw worden uitgevoerd.

Opgeslagen procedures verwijderen

U kunt een in MySQL opgeslagen procedure verwijderen als u deze niet langer wilt gebruiken of als u deze helemaal opnieuw wilt maken. De basissyntaxis voor het verwijderen van de opgeslagen procedure wordt hieronder weergegeven:

DROP PROCEDURE IF EXISTS PROCEDURE_NAME;

Om bijvoorbeeld onze filter_by_category . te verwijderen opgeslagen procedure, voer dan het onderstaande MySQL-commando uit:

DROP PROCEDURE IF EXISTS filter_by_category;

Als de opgeslagen procedure bestaat, krijgt u de onderstaande uitvoer:

Query OK, 0 rows affected (0.00 sec)

Dat is alles als het gaat om het maken, gebruiken en verwijderen van MySQL-opgeslagen procedures.

Meer informatie

U kunt de volgende bronnen raadplegen voor aanvullende informatie over dit onderwerp. Hoewel deze worden verstrekt in de hoop dat ze nuttig zullen zijn, houd er rekening mee dat we niet kunnen instaan voor de nauwkeurigheid of tijdigheid van extern gehost materiaal.

Werken met opgeslagen MySQL-procedures

Opgeslagen MySQL-procedures maken en gebruiken - een zelfstudie

Voordat u begint

Bereid de database voor

De database, tabel en gebruiker maken

De database vullen

Een opgeslagen procedure maken

Opgeslagen proceduresyntaxis

Opgeslagen procedureparameters

Een voorbeeld van een opgeslagen procedure

Een opgeslagen procedure uitvoeren

Opgeslagen procedures verwijderen

Meer informatie