Ricerca nel sito web

Come utilizzare le stored procedure in MySQL

L'autore ha selezionato il programma Write for DOnations.

introduzione

In genere, quando si lavora con un database relazionale, si emette DELETE individuale, direttamente dall'interno del codice dell'applicazione. Queste istruzioni funzionano e manipolano direttamente le tabelle del database sottostante. Se le stesse istruzioni o gruppi di istruzioni vengono utilizzate all'interno di più applicazioni che accedono allo stesso database, spesso vengono duplicate in singole applicazioni.

MySQL, analogamente a molti altri sistemi di gestione di database relazionali, supporta l'uso di stored procedure. Le procedure memorizzate aiutano a raggruppare una o più istruzioni SQL per il riutilizzo con un nome comune, incapsulando la logica aziendale comune all'interno del database stesso. Tale procedura può essere chiamata dall'applicazione che accede al database per recuperare o manipolare i dati in modo coerente.

Utilizzando le stored procedure, puoi creare routine riutilizzabili per attività comuni da utilizzare in più applicazioni, fornire la convalida dei dati o fornire un ulteriore livello di sicurezza dell'accesso ai dati impedendo agli utenti del database di accedere direttamente alle tabelle sottostanti ed emettere query arbitrarie.

In questo tutorial imparerai cosa sono le stored procedure e come creare stored procedure di base che restituiscono dati e utilizzano parametri sia di input che di output.

Prerequisiti

Per seguire questa guida, avrai bisogno di un computer che esegue un sistema di gestione di database relazionali basato su SQL (RDBMS). Le istruzioni e gli esempi in questa guida sono stati convalidati utilizzando il seguente ambiente:

  • Un server che esegue Ubuntu 20.04, con un utente non root con privilegi amministrativi e un firewall configurato con UFW, come descritto nella nostra guida alla configurazione iniziale del server per Ubuntu 20.04.
  • MySQL installato e protetto sul server, come descritto nel passaggio 3.
  • Familiarità di base con l'esecuzione di query SELECT per recuperare i dati dal database come descritto nella nostra guida Come selezionare le righe dalle tabelle in SQL.

Nota: si noti che molti RDBMS utilizzano le proprie implementazioni uniche di SQL e la sintassi delle procedure memorizzate non fa parte dello standard SQL ufficiale. Sebbene i comandi delineati in questo tutorial possano funzionare in altri RDBMS, le stored procedure sono specifiche del database e quindi la sintassi o l'output esatto potrebbero differire se le si testa su un sistema diverso da MySQL.

Avrai anche bisogno di un database vuoto in cui sarai in grado di creare tabelle che dimostrino l'uso delle procedure memorizzate. Ti invitiamo a consultare la seguente sezione Connessione a MySQL e configurazione di un database di esempio per i dettagli sulla connessione a un server MySQL e sulla creazione del database di test utilizzato negli esempi di questa guida.

Connessione a MySQL e impostazione di un database di esempio

In questa sezione, ti collegherai a un server MySQL e creerai un database di esempio in modo da poter seguire gli esempi in questa guida.

Per questa guida utilizzerai una collezione di auto immaginaria. Memorizzerai i dettagli sulle auto attualmente in tuo possesso, con la loro marca, modello, anno di costruzione e valore.

Se il tuo sistema di database SQL viene eseguito su un server remoto, SSH nel tuo server dalla tua macchina locale:

  1. ssh sammy@your_server_ip

Quindi apri il prompt del server MySQL, sostituendo sammy con il nome del tuo account utente MySQL:

  1. mysql -u sammy -p

Crea un database chiamato procedure:

  1. CREATE DATABASE procedures;

Se il database è stato creato correttamente, riceverai un output come questo:

Output
Query OK, 1 row affected (0.01 sec)

Per selezionare il database procedures, eseguire la seguente istruzione USE:

  1. USE procedures;

Riceverai il seguente output:

Output
Database changed

Dopo aver selezionato il database, puoi creare tabelle di esempio al suo interno. La tabella cars conterrà dati semplificati sulle auto nel database. Conterrà le seguenti colonne:

  • marca: questa colonna contiene la marca di ogni auto di proprietà, espressa utilizzando il tipo di dati varchar con un massimo di 100 caratteri.< /li>
  • model: questa colonna contiene il nome del modello dell'auto, espresso utilizzando il tipo di dati varchar con un massimo di 100 caratteri.
  • anno: questa colonna memorizza l'anno di costruzione dell'auto con il tipo di dati int per contenere i valori numerici.
  • valore: questa colonna memorizza il valore dell'auto utilizzando il tipo di dati decimal con un massimo di 10 cifre e 2 cifre dopo la virgola.

Crea la tabella di esempio con il seguente comando:

  1. CREATE TABLE cars (

  2.     make varchar(100),

  3.     model varchar(100),

  4.     year int,

  5.     value decimal(10, 2)

  6. );

Se viene stampato il seguente output, la tabella è stata creata:

Output
Query OK, 0 rows affected (0.00 sec)

Successivamente, carica la tabella cars con alcuni dati di esempio eseguendo la seguente operazione INSERT INTO:

  1. INSERT INTO cars

  2. VALUES

  3. ('Porsche', '911 GT3', 2020, 169700),

  4. ('Porsche', 'Cayman GT4', 2018, 118000),

  5. ('Porsche', 'Panamera', 2022, 113200),

  6. ('Porsche', 'Macan', 2019, 27400),

  7. ('Porsche', '718 Boxster', 2017, 48880),

  8. ('Ferrari', '488 GTB', 2015, 254750),

  9. ('Ferrari', 'F8 Tributo', 2019, 375000),

  10. ('Ferrari', 'SF90 Stradale', 2020, 627000),

  11. ('Ferrari', '812 Superfast', 2017, 335300),

  12. ('Ferrari', 'GTC4Lusso', 2016, 268000);

L'operazione INSERT INTO aggiungerà dieci modelli di auto sportive alla tabella, con cinque modelli Porsche e cinque Ferrari. Il seguente output indica che tutte e cinque le righe sono state aggiunte:

Output
Query OK, 10 rows affected (0.00 sec)
Records: 10  Duplicates: 0  Warnings: 0

Detto questo, sei pronto per seguire il resto della guida e iniziare a utilizzare le stored procedure in SQL.

Introduzione alle stored procedure

Le stored procedure in MySQL e in molti altri sistemi di database relazionali sono oggetti denominati che contengono una o più istruzioni disposte e quindi eseguite dal database in sequenza quando vengono chiamate. Nell'esempio più semplice, una stored procedure può salvare un'istruzione comune in una routine riutilizzabile, ad esempio il recupero di dati dal database con filtri usati spesso. Ad esempio, è possibile creare una stored procedure per recuperare i clienti del negozio online che hanno effettuato ordini nell'ultimo numero di mesi specificato. Negli scenari più complessi, le stored procedure possono rappresentare programmi estesi che descrivono complesse logiche di business per applicazioni robuste.

L'insieme di istruzioni in una procedura memorizzata può includere istruzioni SQL comuni, come query INSERT, che restituiscono o manipolano dati. Inoltre, le stored procedure possono utilizzare:

  • Parametri passati alla stored procedure o restituiti attraverso di essa.
  • Variabili dichiarate per elaborare i dati recuperati direttamente all'interno del codice della procedura.
  • Dichiarazioni condizionali, che consentono l'esecuzione di parti del codice della procedura memorizzata in base a determinate condizioni, come le istruzioni IF o CASE.
  • I loop, come WHILE, LOOP e REPEAT, consentono di eseguire parti del codice più volte, ad esempio per ogni riga in un set di dati recuperato.
  • Istruzioni per la gestione degli errori, come la restituzione di messaggi di errore agli utenti del database che accedono alla procedura.
  • Chiamate ad altre stored procedure nel database.

Nota: l'ampia sintassi supportata da MySQL consente di scrivere programmi robusti e risolvere problemi complessi con procedure memorizzate. Questa guida copre solo l'utilizzo di base delle stored procedure con istruzioni SQL racchiuse nel corpo della stored procedure, nei parametri di input e di output. L'esecuzione di codice condizionale, l'utilizzo di variabili, cicli e la gestione degli errori personalizzata non rientrano nell'ambito di questa guida. Ti invitiamo a saperne di più sulle stored procedure nella documentazione ufficiale di MySQL.

Quando la procedura viene chiamata con il suo nome, il motore del database la esegue come definito, istruzione per istruzione.

L'utente del database deve disporre delle autorizzazioni appropriate per eseguire la procedura specificata. Questo requisito di autorizzazione fornisce un livello di sicurezza, impedendo l'accesso diretto al database e fornendo agli utenti l'accesso a singole procedure garantite come sicure da eseguire.

Le stored procedure vengono eseguite direttamente sul server del database, eseguendo tutti i calcoli localmente e restituendo i risultati all'utente chiamante solo al termine.

Se si desidera modificare il comportamento della procedura, è possibile aggiornare la procedura nel database e le applicazioni che la stanno utilizzando rileveranno automaticamente la nuova versione. Tutti gli utenti inizieranno immediatamente a utilizzare il nuovo codice di procedura senza dover modificare le proprie applicazioni.

Ecco la struttura generale del codice SQL utilizzato per creare una stored procedure:

  1. DELIMITER //

  2. CREATE PROCEDURE procedure_name(parameter_1, parameter_2, . . ., parameter_n)

  3. BEGIN

  4.     instruction_1;

  5.     instruction_2;

  6.     . . .

  7.     instruction_n;

  8. END //

  9. DELIMITER ;

La prima e l'ultima istruzione in questo frammento di codice sono DELIMITER // e DELIMITER ;. Di solito, MySQL usa il simbolo del punto e virgola (;) per delimitare le istruzioni e indicare quando iniziano e finiscono. Se esegui più istruzioni nella console MySQL separate da punti e virgola, verranno trattate come comandi separati ed eseguite indipendentemente, una dopo l'altra. Tuttavia, la procedura memorizzata può racchiudere più comandi che verranno eseguiti in sequenza quando viene chiamata. Ciò pone una difficoltà quando si cerca di dire a MySQL di creare una nuova procedura. Il motore di database incontrerebbe il segno del punto e virgola nel corpo della procedura memorizzata e penserebbe che dovrebbe interrompere l'esecuzione dell'istruzione. In questa situazione, l'istruzione prevista è l'intero codice di creazione della procedura, non una singola istruzione all'interno della procedura stessa, quindi MySQL interpreterebbe erroneamente le tue intenzioni.

Per aggirare questa limitazione, utilizza il comando DELIMITER per modificare temporaneamente il delimitatore da ; a // per la durata del CREATE PROCEDURE chiamata. Quindi, tutti i punti e virgola all'interno del corpo della stored procedure verranno passati al server così come sono. Al termine dell'intera procedura, il delimitatore viene nuovamente modificato in ; con l'ultimo DELIMITER ;.

Il cuore del codice per creare una nuova procedura è la chiamata CREATE PROCEDURE seguita dal nome della procedura: procedure_name nell'esempio. Il nome della procedura è seguito da un elenco facoltativo di parametri che la procedura accetterà. L'ultima parte è il corpo della procedura, racchiuso tra le istruzioni BEGIN e END. All'interno c'è il codice della procedura, che può contenere una singola istruzione SQL come una query SELECT o un codice più complesso.

Il comando END termina con //, un delimitatore temporaneo, invece del tipico punto e virgola.

Nella sezione successiva, creerai una stored procedure di base senza parametri che racchiudono una singola query.

Creazione di una stored procedure senza parametri

In questa sezione, creerai la tua prima stored procedure incapsulando una singola istruzione SQL SELECT per restituire l'elenco delle auto di proprietà ordinate per marca e valore in ordine decrescente.

Inizia eseguendo l'istruzione SELECT che utilizzerai:

  1. SELECT * FROM cars ORDER BY make, value DESC;

Il database restituirà l'elenco delle auto dalla tabella cars, prima ordinate per marca e poi, all'interno di una singola marca, per valore in ordine decrescente:

Output
+---------+---------------+------+-----------+
| make    | model         | year | value     |
+---------+---------------+------+-----------+
| Ferrari | SF90 Stradale | 2020 | 627000.00 |
| Ferrari | F8 Tributo    | 2019 | 375000.00 |
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Ferrari | GTC4Lusso     | 2016 | 268000.00 |
| Ferrari | 488 GTB       | 2015 | 254750.00 |
| Porsche | 911 GT3       | 2020 | 169700.00 |
| Porsche | Cayman GT4    | 2018 | 118000.00 |
| Porsche | Panamera      | 2022 | 113200.00 |
| Porsche | 718 Boxster   | 2017 |  48880.00 |
| Porsche | Macan         | 2019 |  27400.00 |
+---------+---------------+------+-----------+
10 rows in set (0.00 sec)

La Ferrari più preziosa è in cima alla lista e la Porsche meno preziosa appare in fondo.

Si supponga che questa query verrà utilizzata frequentemente in più applicazioni o da più utenti e si supponga di voler garantire che tutti utilizzino esattamente lo stesso modo di ordinare i risultati. Per fare ciò, si desidera creare una procedura memorizzata che salverà tale istruzione in una procedura denominata riutilizzabile.

Per creare questa stored procedure, eseguire il seguente frammento di codice:

  1. DELIMITER //

  2. CREATE PROCEDURE get_all_cars()

  3. BEGIN

  4.     SELECT * FROM cars ORDER BY make, value DESC;

  5. END //

  6. DELIMITER ;

Come descritto nella sezione precedente, il primo e l'ultimo comando (DELIMITER // e DELIMITER ;) dicono a MySQL di smettere di trattare il carattere punto e virgola come delimitatore di istruzioni per la durata di creazione della procedura.

Il comando SQL CREATE PROCEDURE è seguito dal nome della procedura get_all_cars, che puoi definire per descrivere al meglio cosa fa la procedura. Dopo il nome della procedura, c'è una coppia di parentesi () dove puoi aggiungere parametri. In questo esempio, la procedura non utilizza parametri, quindi le parentesi sono vuote. Quindi, tra i comandi BEGIN e END che definiscono l'inizio e la fine del blocco di codice della procedura, viene scritta testualmente l'istruzione SELECT utilizzata in precedenza.

Nota: a seconda delle tue autorizzazioni utente MySQL, potresti ricevere un errore durante l'esecuzione del comando CREATE PROCEDURE: ERROR 1044 (42000): Accesso negato per l'utente sammy@ localhost alle procedure del database. Per concedere le autorizzazioni per creare ed eseguire procedure memorizzate al tuo utente, accedi a MySQL come root ed esegui i seguenti comandi, sostituendo il nome utente e l'host MySQL secondo necessità:

  1. GRANT CREATE ROUTINE, ALTER ROUTINE, EXECUTE on *.* TO 'sammy'@'localhost';

  2. FLUSH PRIVILEGES;

Dopo aver aggiornato le autorizzazioni utente, disconnettiti come root, accedi nuovamente come utente ed esegui nuovamente l'istruzione CREATE PROCEDURE.

Puoi saperne di più sull'applicazione delle autorizzazioni relative alle stored procedure agli utenti del database nella documentazione sulle stored procedure e sui privilegi MySQL.

Il database risponderà con un messaggio di successo:

Output
Query OK, 0 rows affected (0.02 sec)

La procedura get_all_cars è ora salvata nel database e, quando viene chiamata, eseguirà l'istruzione salvata così com'è.

Per eseguire le stored procedure salvate, puoi utilizzare il comando SQL CALL seguito dal nome della procedura. Prova a eseguire la procedura appena creata in questo modo:

  1. CALL get_all_cars;

Il nome della procedura, get_all_cars, è tutto ciò di cui hai bisogno per utilizzare la procedura. Non è più necessario digitare manualmente alcuna parte dell'istruzione SELECT utilizzata in precedenza. Il database visualizzerà i risultati proprio come l'output dell'istruzione SELECT eseguita prima:

Output
+---------+---------------+------+-----------+
| make    | model         | year | value     |
+---------+---------------+------+-----------+
| Ferrari | SF90 Stradale | 2020 | 627000.00 |
| Ferrari | F8 Tributo    | 2019 | 375000.00 |
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Ferrari | GTC4Lusso     | 2016 | 268000.00 |
| Ferrari | 488 GTB       | 2015 | 254750.00 |
| Porsche | 911 GT3       | 2020 | 169700.00 |
| Porsche | Cayman GT4    | 2018 | 118000.00 |
| Porsche | Panamera      | 2022 | 113200.00 |
| Porsche | 718 Boxster   | 2017 |  48880.00 |
| Porsche | Macan         | 2019 |  27400.00 |
+---------+---------------+------+-----------+
10 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

Ora hai creato con successo una stored procedure senza alcun parametro che restituisce tutte le auto dalla tabella cars ordinate in un modo particolare. È possibile utilizzare la procedura su più applicazioni.

Nella sezione successiva, creerai una procedura che accetta parametri per modificare il comportamento della procedura in base all'input dell'utente.

Creazione di una stored procedure con un parametro di input

In questa sezione, includerai i parametri di input alla definizione della stored procedure per consentire agli utenti che eseguono la procedura di passarvi i dati. Ad esempio, gli utenti potrebbero fornire filtri di query.

La stored procedure get_all_cars creata in precedenza ha recuperato tutte le auto dalla tabella cars in ogni momento. Creiamo un'altra procedura per trovare le auto di un determinato anno di produzione. Per consentire ciò, definirai un parametro denominato nella definizione della procedura.

Esegui il seguente codice:

  1. DELIMITER //

  2. CREATE PROCEDURE get_cars_by_year(

  3.     IN year_filter int

  4. )

  5. BEGIN

  6.     SELECT * FROM cars WHERE year = year_filter ORDER BY make, value DESC;

  7. END //

  8. DELIMITER ;

Sono state apportate diverse modifiche al codice di creazione della procedura rispetto alla sezione precedente.

Innanzitutto, il nome è get_cars_by_year, che descrive la procedura: recuperare le auto in base al loro anno di produzione.

Le parentesi precedentemente vuote ora contengono un'unica definizione di parametro: IN year_filter int. La parola chiave IN indica al database che il parametro verrà passato dall'utente chiamante nella procedura. year_filter è un nome arbitrario per il parametro. Lo utilizzerai per fare riferimento al parametro nel codice della procedura. Infine, int è il tipo di dati. In questo caso l'anno di produzione è espresso come valore numerico.

Il parametro year_filter definito dopo il nome della procedura appare nell'istruzione SELECT nella clausola WHERE year=year_filter, filtrando la tabella cars rispetto al loro anno di produzione.

Il database risponderà ancora una volta con un messaggio di successo:

Output
Query OK, 0 rows affected (0.02 sec)

Prova a eseguire la procedura senza passare alcun parametro, proprio come hai fatto in precedenza:

  1. CALL get_cars_by_year;

Il database MySQL restituirà un messaggio di errore:

Error message
ERROR 1318 (42000): Incorrect number of arguments for PROCEDURE procedures.get_cars_by_year; expected 1, got 0

Questa volta, la stored procedure prevede che venga fornito un parametro, ma non ne è stato fornito nessuno. Per chiamare una stored procedure con parametri, è possibile fornire i valori dei parametri tra parentesi nello stesso ordine previsto dalla procedura. Per recuperare le auto prodotte nel 2017, eseguire:

  1. CALL get_cars_by_year(2017);

Ora, la procedura chiamata verrà eseguita correttamente e restituirà l'elenco delle auto di quell'anno:

Output
+---------+---------------+------+-----------+
| make    | model         | year | value     |
+---------+---------------+------+-----------+
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Porsche | 718 Boxster   | 2017 |  48880.00 |
+---------+---------------+------+-----------+
2 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

In questo esempio si è appreso come passare i parametri di input alle stored procedure e utilizzarli nelle query all'interno di una procedura per fornire opzioni di filtro.

Nella sezione successiva, utilizzerai i parametri di output per creare procedure che restituiscono più valori diversi in una singola esecuzione.

Creazione di una stored procedure con parametri di input e output

In entrambi gli esempi precedenti, le stored procedure create hanno chiamato un'istruzione SELECT per ottenere un set di risultati. In alcuni casi, tuttavia, potrebbe essere necessaria una stored procedure che restituisca più valori diversi insieme invece di un singolo set di risultati per una singola query.

Si supponga di voler creare una procedura che fornisca informazioni riassuntive sulle auto di un determinato anno, inclusa la quantità di auto nella collezione e il relativo valore di mercato (minimo, massimo e medio).

Per farlo, puoi usare i parametri OUT quando crei una nuova stored procedure. Analogamente ai parametri IN, i parametri OUT hanno nomi e tipi di dati ad essi associati. Tuttavia, invece di passare i dati alla stored procedure, possono essere riempiti con i dati dalla stored procedure per restituire i valori all'utente chiamante.

Crea una procedura get_car_stats_by_year che restituirà dati di riepilogo sulle auto di un determinato anno di produzione utilizzando i parametri di output:

  1. DELIMITER //

  2. CREATE PROCEDURE get_car_stats_by_year(

  3.     IN year_filter int,

  4.     OUT cars_number int,

  5.     OUT min_value decimal(10, 2),

  6.     OUT avg_value decimal(10, 2),

  7.     OUT max_value decimal(10, 2)

  8. )

  9. BEGIN

  10.     SELECT COUNT(*), MIN(value), AVG(value), MAX(value)

  11.     INTO cars_number, min_value, avg_value, max_value

  12.     FROM cars

  13.     WHERE year = year_filter ORDER BY make, value DESC;

  14. END //

  15. DELIMITER ;

Questa volta, accanto al parametro IN year_filter utilizzato per filtrare le auto in base all'anno di produzione, nel blocco delle parentesi sono definiti quattro parametri OUT. Il parametro cars_number è rappresentato con il tipo di dati int e verrà utilizzato per restituire il numero di auto nella raccolta. I parametri min_value, avg_value e max_value rappresentano il valore di mercato e sono definiti con il tipo decimal(10, 2) (simile alla colonna value nella tabella cars). Questi verranno utilizzati per restituire informazioni sulle auto più economiche e più costose della collezione, nonché il prezzo medio di tutte le auto corrispondenti.

L'istruzione SELECT interroga quattro valori dalla tabella cars utilizzando le funzioni matematiche SQL: COUNT per ottenere il numero totale di auto e MIN , AVG e MAX per ottenere il valore minimo, medio e massimo dalla colonna value.

Nota:

Per indicare al database che i risultati di quella query dovrebbero essere memorizzati nei parametri di output della stored procedure, viene introdotta una nuova parola chiave, INTO. Dopo la parola chiave INTO, vengono elencati i nomi di quattro parametri della procedura corrispondenti ai dati recuperati. Con questo, MySQL salverà il valore COUNT(*) nel parametro cars_number, il MIN(value) result nel parametro min_value e così via.

Il database confermerà l'avvenuta creazione della procedura:

Output
Query OK, 0 rows affected (0.02 sec)

Ora, esegui la nuova procedura eseguendo:

  1. CALL get_car_stats_by_year(2017, @number, @min, @avg, @max);

I quattro nuovi parametri iniziano con il segno @. Questi sono nomi di variabili locali nella console MySQL che puoi utilizzare per archiviare temporaneamente i dati. Quando li passi alla procedura memorizzata che hai appena creato, la procedura inserirà valori in quelle variabili.

Il database risponderà con:

Output
Query OK, 1 row affected (0.00 sec)

È diverso dal comportamento precedente, in cui i risultati venivano immediatamente visualizzati sullo schermo. Questo perché i risultati della stored procedure sono stati salvati nei parametri di output e non restituiti come risultato della query. Per accedere ai risultati, puoi SELECT direttamente nella shell MySQL come segue:

  1. SELECT @number, @min, @avg, @max;

Con questa query, stai selezionando i valori dalle variabili locali, senza chiamare di nuovo la procedura. La stored procedure ha salvato i suoi risultati in quelle variabili e i dati rimarranno disponibili fino a quando non ti disconnetti dalla shell.

Nota:

L'output visualizzerà i valori per le variabili interrogate:

Output
+---------+----------+-----------+-----------+
| @number | @min     | @avg      | @max      |
+---------+----------+-----------+-----------+
|       2 | 48880.00 | 192090.00 | 335300.00 |
+---------+----------+-----------+-----------+
1 row in set (0.00 sec)

I valori corrispondono al numero di auto prodotte nel 2017, nonché al valore di mercato minimo, medio e massimo delle auto di questo anno di produzione.

In questo esempio si è appreso come utilizzare i parametri di output per restituire più valori diversi dall'interno della stored procedure per un uso successivo. Nella prossima sezione imparerai come rimuovere le procedure create.

Rimozione di stored procedure

In questa sezione, rimuoverai le stored procedure presenti nel database.

A volte la procedura che hai creato potrebbe non essere più necessaria. In altre circostanze, potresti voler cambiare il modo in cui funziona la procedura. MySQL non consente di modificare la definizione della procedura dopo la creazione, quindi l'unico modo per farlo è rimuovere prima la procedura e ricrearla con le modifiche desiderate.

Rimuoviamo l'ultima procedura, get_car_stats_by_year. Per farlo, puoi utilizzare l'istruzione DROP PROCEDURE:

  1. DROP PROCEDURE get_car_stats_by_year;

Il database confermerà l'avvenuta cancellazione della procedura con un messaggio di successo:

Output
Query OK, 0 rows affected (0.02 sec)

Puoi verificare che la procedura sia stata eliminata provando a chiamarla. Eseguire:

  1. CALL get_car_stats_by_year(2017, @number, @min, @avg, @max);

Questa volta, vedrai un messaggio di errore che dice che la procedura non è presente nel database:

Error message
ERROR 1305 (42000): PROCEDURE procedures.get_car_stats_by_year does not exist

In questa sezione, hai imparato come eliminare le stored procedure esistenti nel database.

Conclusione

Seguendo questa guida, hai imparato cosa sono le stored procedure e come usarle in MySQL per salvare istruzioni riutilizzabili in procedure denominate ed eseguirle successivamente. Hai creato stored procedure senza parametri e procedure che utilizzano parametri di input e output per renderle più flessibili.

È possibile utilizzare le procedure memorizzate per creare routine riutilizzabili e unificare i metodi per accedere ai dati in più applicazioni, nonché implementare comportamenti complessi che superano le possibilità fornite dalle singole query SQL. Questa esercitazione ha coperto solo le nozioni di base sull'utilizzo delle stored procedure. Per saperne di più, consulta la documentazione di MySQL sulle stored procedure.

Se desideri saperne di più sui diversi concetti relativi al linguaggio SQL e lavorare con esso, ti invitiamo a consultare le altre guide nella serie How To Use SQL.