Creazione e utilizzo di stored procedure MySQL:un tutorial

Le stored procedure sono istruzioni SQL definite dall'utente che vengono archiviate in un database MySQL ed eseguite su richiesta per eseguire un'operazione specifica del database. Queste subroutine predefinite aiutano a spostare la logica aziendale nel database, il che offre alcuni vantaggi:

I viaggi di andata e ritorno effettuati da un'applicazione al server del database sono ridotti al minimo.
La manutenibilità del codice è stata migliorata, poiché diverse applicazioni possono condividere la procedura memorizzata.
Le prestazioni del database sono migliorate, perché le procedure memorizzate vengono compilate una sola volta ed eseguite in modo molto rapido ed efficiente.

In questa guida:

Impara la sintassi per la creazione di stored procedure e dichiara la tua prima procedura.
Esegui la procedura di esempio dopo averla dichiarata.
Scopri come eliminare una procedura quando non ti serve più.

Prima di iniziare

Assicurati di avere quanto segue:

Se non l'hai già fatto, crea un account Linode e un'istanza di calcolo. Consulta le nostre guide Introduzione a Linode e Creazione di un'istanza di calcolo.
Segui la nostra guida alla configurazione e alla protezione di un'istanza di calcolo per aggiornare il tuo sistema. Potresti anche voler impostare il fuso orario, configurare il tuo nome host, creare un account utente limitato e rafforzare l'accesso SSH.
Un server e un client MySQL installati sul server Linode. Le guide all'installazione di MySQL sono disponibili per diverse distribuzioni nella nostra sezione MySQL.

Prepara il database

Inizierai creando un database, una tabella e un utente di esempio per l'accesso al database. Popolerai anche la tabella con dati di esempio a scopo di test.

Creazione del database, della tabella e dell'utente

Accedi al server MySQL:
```
 mysql -u root -p
```
Ti verrà chiesto di inserire la password di root del tuo database MySQL. Quindi, premi Invio per continuare.
Successivamente, vedrai un prompt MySQL simile a quello mostrato di seguito.
```
mysql >
```
Immettere il comando seguente per creare un test_db banca dati:
```
CREATE DATABASE test_db;
```
Uscita:
```
Query OK, 1 row affected (0.01 sec)
```
Crea un utente del database e concedi l'accesso completo a test_db Banca dati. Sostituisci PASSWORD con un valore complesso e univoco che segue le linee guida per le password MySQL:
```
CREATE USER 'test_user'@'localhost' IDENTIFIED BY 'PASSWORD';
```
Uscita:
```
Query OK, 1 row affected (0.01 sec)
```

Concedi il test_user privilegi completi per test_db banca dati;

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

Uscita:

Query OK, 1 row affected (0.01 sec)

Privilegi di svuotamento:

FLUSH PRIVILEGES;

Uscita:

Query OK, 0 rows affected (0.01 sec)

Popola il database

Quindi, passa al database test_db:
```
USE test_db;
```
Uscita:
```
Database changed
```

Crea un products tabella per memorizzare record di esempio:

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

Uscita:

Query OK, 0 rows affected (0.01 sec)

Ora puoi aggiungere alcuni prodotti alla tabella dei prodotti eseguendo i comandi seguenti uno per uno:

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');

Dovresti ottenere l'output seguente dopo aver eseguito ogni Insert dichiarazione:

Query OK, 1 row affected (0.00 sec)

Prossimo. confermare se i prodotti campione sono stati inseriti correttamente nel database eseguendo il comando Select comando seguente:

SELECT * FROM products;

I tuoi prodotti di esempio dovrebbero essere elencati come mostrato di seguito:

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

Esci dal server MySQL.
```
QUIT;
```
Uscita:
```
Bye!
```
Dopo aver creato un test_db database, products tabella, un test_user , e aggiunti alcuni prodotti di esempio, ora puoi passare alla creazione della prima stored procedure.

Creazione di una stored procedure

Sintassi stored procedure

La sintassi di base per la creazione di una procedura memorizzata nel database MySQL è mostrata di seguito:

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

Il DELIMITER && la riga all'inizio dice al server MySQL di trattare le seguenti istruzioni SQL come una singola istruzione, piuttosto che eseguirle singolarmente. Un altro && è incluso in una riga successiva per segnare la fine di questa affermazione.
PROCEDURE_NAME è dove viene dichiarato il nome della tua stored procedure.
Il nome della procedura è seguito da una serie di parentesi che racchiudono i parametri della procedura. Le stored procedure supportano parametri separati da virgole e questa funzionalità li rende più flessibili. Vedi la sezione parametri per maggiori dettagli.
Il BEGIN...END I comandi racchiudono l'istruzione SQL che si desidera venga eseguita dalla procedura memorizzata.
Alla fine, l'istruzione DELIMITER ; viene emesso di nuovo per riportare il delimitatore al valore predefinito di ;

Parametri stored procedure

Ogni parametro per una procedura ha un tipo, un nome e un tipo di dati, separati da spazi:

PARAMETER_TYPE PARAMETER_NAME DATA_TYPE

Ad esempio, per creare un parametro di tipo IN , denominato category , con il VARCHAR tipo di dati con una lunghezza di 50 caratteri, usa questa sintassi:

IN category VARCHAR(50)

MySQL supporta tre tipi di parametri:

IN :Il valore del parametro deve essere specificato dal client chiamante. Questo valore non può essere modificato dalla procedura memorizzata .

Ad esempio, se passi una variabile di sessione MySQL come IN parametro a una procedura e la procedura modifica questo valore nelle sue istruzioni, la tua variabile di sessione rimarrà invariata dopo la chiusura della procedura.
OUT :Questo tipo di parametro è specificato anche dal programma chiamante, ma il suo valore può essere modificato dalla procedura memorizzata e recuperato dal programma chiamante.

Si noti che la procedura memorizzata non può accedere al valore iniziale di una variabile passata come OUT parametro.
INOUT :Un parametro di questo tipo combina i comportamenti di IN e OUT parametri:
- La procedura memorizzata può leggere il valore iniziale del parametro.
- Il parametro può essere modificato durante l'esecuzione della procedura memorizzata.
- Il valore modificato può essere restituito al programma chiamante, se il programma chiamante ha passato una variabile come parametro.

Un esempio di stored procedure

Dopo aver compreso la sintassi di base, creiamo una semplice stored procedure per filtrare i prodotti in base al nome della categoria. Il nome della categoria verrà fornito come IN parametro.

Accedi al server MySQL utilizzando test_user le credenziali che hai creato durante la preparazione del database:
```
 mysql -u test_user -p
```
Inserisci la password del test_user e premi Invio per continuare.
Riceverai un mysql > richiesta. Procedi selezionando il test_db :
```
 USE test_db;
```
Uscita:
```
Database changed.
```

Quindi, inserisci i comandi SQL di seguito per creare un filter_by_category procedura memorizzata:

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

Uscita:

Query OK, 0 rows affected (0.00 sec)

Modifica il DELIMITER torna a ;
```
DELIMITER ;
```
Se il codice per la creazione della procedura memorizzata è stato eseguito correttamente, ora puoi passare all'esecuzione della procedura memorizzata.

Esecuzione di una stored procedure

In questo passaggio, chiameremo la stored procedure che abbiamo creato sopra. Seguiremo questa sintassi di base:

CALL PROCEDURE_NAME (COMMA-SEPARATED PARAMETER VALUES);

Per eseguire il filter_by_category stored procedure che abbiamo creato sopra, inserisci il comando seguente:

CALL filter_by_category('COMPUTER ACCESSORIES');

La procedura memorizzata dovrebbe ora restituire tutti i prodotti in COMPUTER ACCESSORIES categoria perché abbiamo specificato COMPUTER ACCESSORIES come parametro:

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

Allo stesso modo, puoi recuperare un elenco di tutti i prodotti dal ELECTRONICS categoria eseguendo il comando seguente.

CALL filter_by_category('ELECTRONICS') ;

Uscita:

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

La nostra procedura memorizzata ha funzionato come ci aspettavamo. Successivamente, impareremo come eliminare le stored procedure se non desideriamo più che vengano eseguite nuovamente.

Eliminazione di stored procedure

È possibile eliminare una stored procedure MySQL se non si desidera più utilizzarla o se si desidera ricrearla da zero. La sintassi di base per eliminare la stored procedure è mostrata di seguito:

DROP PROCEDURE IF EXISTS PROCEDURE_NAME;

Ad esempio, per eliminare il nostro filter_by_category stored procedure, eseguire il comando MySQL di seguito:

DROP PROCEDURE IF EXISTS filter_by_category;

Se la procedura memorizzata esiste, otterrai l'output mostrato di seguito:

Query OK, 0 rows affected (0.00 sec)

Questo è tutto quando si tratta di creare, utilizzare e rilasciare stored procedure MySQL.

Maggiori informazioni

Si consiglia di consultare le seguenti risorse per ulteriori informazioni su questo argomento. Sebbene questi siano forniti nella speranza che possano essere utili, tieni presente che non possiamo garantire l'accuratezza o la tempestività dei materiali ospitati esternamente.

Lavorare con le stored procedure MySQL