Como usar procedimentos armazenados no MySQL

O autor selecionou o programa Write for DOnations.

Introdução

Normalmente, ao trabalhar com um banco de dados relacional, você emite DELETE individual, diretamente do código do aplicativo. Essas instruções trabalham e manipulam diretamente as tabelas de banco de dados subjacentes. Se as mesmas instruções ou grupo de instruções forem usadas em vários aplicativos que acessam o mesmo banco de dados, elas geralmente serão duplicadas em aplicativos individuais.

MySQL, semelhante a muitos outros sistemas de gerenciamento de banco de dados relacional, suporta o uso de stored procedures. Os procedimentos armazenados ajudam a agrupar uma ou várias instruções SQL para reutilização sob um nome comum, encapsulando a lógica comercial comum no próprio banco de dados. Tal procedimento pode ser chamado a partir do aplicativo que acessa o banco de dados para recuperar ou manipular dados de forma consistente.

Usando procedimentos armazenados, você pode criar rotinas reutilizáveis para tarefas comuns a serem usadas em vários aplicativos, fornecer validação de dados ou fornecer uma camada adicional de segurança de acesso a dados, restringindo os usuários do banco de dados de acessar as tabelas subjacentes diretamente e emitir consultas arbitrárias.

Neste tutorial, você aprenderá o que são procedimentos armazenados e como criar procedimentos armazenados básicos que retornam dados e usam parâmetros de entrada e saída.

Pré-requisitos

Para seguir este guia, você precisará de um computador executando um sistema de gerenciamento de banco de dados relacional (RDBMS) baseado em SQL. As instruções e exemplos neste guia foram validados usando o seguinte ambiente:

• Um servidor executando o Ubuntu 20.04, com um usuário não root com privilégios administrativos e um firewall configurado com UFW, conforme descrito em nosso guia inicial de configuração do servidor para Ubuntu 20.04.
• MySQL instalado e protegido no servidor, conforme descrito na Etapa 3.
• Familiaridade básica com a execução de consultas SELECT para recuperar dados do banco de dados, conforme descrito em nosso guia Como selecionar linhas de tabelas em SQL.

Observação: observe que muitos RDBMSs usam suas próprias implementações exclusivas de SQL e a sintaxe de procedimentos armazenados não faz parte do padrão SQL oficial. Embora os comandos descritos neste tutorial possam funcionar em outros RDBMSs, os procedimentos armazenados são específicos do banco de dados e, portanto, a sintaxe ou a saída exata podem diferir se você testá-los em um sistema diferente do MySQL.

Você também precisará de um banco de dados vazio no qual poderá criar tabelas demonstrando o uso de stored procedures. Recomendamos que você consulte a seção Conectando ao MySQL e configurando um banco de dados de exemplo para obter detalhes sobre como conectar a um servidor MySQL e criar o banco de dados de teste usado nos exemplos deste guia.

Conectando-se ao MySQL e configurando um banco de dados de amostra

Nesta seção, você se conectará a um servidor MySQL e criará um banco de dados de exemplo para poder seguir os exemplos deste guia.

Para este guia, você usará uma coleção imaginária de carros. Você armazenará detalhes sobre carros de propriedade atual, com sua marca, modelo, ano de construção e valor.

Se o seu sistema de banco de dados SQL for executado em um servidor remoto, faça SSH em seu servidor a partir de sua máquina local:

ssh sammy@your_server_ip

Em seguida, abra o prompt do servidor MySQL, substituindo sammy pelo nome da sua conta de usuário do MySQL:

mysql -u sammy -p

Crie um banco de dados chamado procedures:

CREATE DATABASE procedures;

Se o banco de dados foi criado com sucesso, você receberá uma saída como esta:

Output
Query OK, 1 row affected (0.01 sec)

Para selecionar o banco de dados procedures, execute a seguinte instrução USE:

USE procedures;

Você receberá a seguinte saída:

Output
Database changed

Depois de selecionar o banco de dados, você pode criar tabelas de amostra dentro dele. A tabela cars conterá dados simplificados sobre carros no banco de dados. Ele conterá as seguintes colunas:

• make: Esta coluna contém a marca de cada carro possuído, expressa usando o tipo de dados varchar com um máximo de 100 caracteres.< /li>
• model: Esta coluna contém o nome do modelo do carro, expresso usando o tipo de dados varchar com no máximo 100 caracteres.
• ano: esta coluna armazena o ano de construção do carro com o tipo de dados int para armazenar valores numéricos.
• valor: Esta coluna armazena o valor do carro usando o tipo de dados decimal com no máximo 10 dígitos e 2 dígitos após o ponto decimal.

Crie a tabela de amostra com o seguinte comando:

CREATE TABLE cars (
    make varchar(100),
    model varchar(100),
    year int,
    value decimal(10, 2)
);

Se a seguinte saída for impressa, a tabela foi criada:

Output
Query OK, 0 rows affected (0.00 sec)

Em seguida, carregue a tabela cars com alguns dados de amostra executando a seguinte operação INSERT INTO:

INSERT INTO cars
VALUES
('Porsche', '911 GT3', 2020, 169700),
('Porsche', 'Cayman GT4', 2018, 118000),
('Porsche', 'Panamera', 2022, 113200),
('Porsche', 'Macan', 2019, 27400),
('Porsche', '718 Boxster', 2017, 48880),
('Ferrari', '488 GTB', 2015, 254750),
('Ferrari', 'F8 Tributo', 2019, 375000),
('Ferrari', 'SF90 Stradale', 2020, 627000),
('Ferrari', '812 Superfast', 2017, 335300),
('Ferrari', 'GTC4Lusso', 2016, 268000);

A operação INSERT INTO adicionará dez exemplos de carros esportivos à tabela, com cinco modelos Porsche e cinco modelos Ferrari. A saída a seguir indica que todas as cinco linhas foram adicionadas:

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

Com isso, você está pronto para seguir o restante do guia e começar a usar stored procedures em SQL.

Introdução aos Procedimentos Armazenados

Os procedimentos armazenados no MySQL e em muitos outros sistemas de banco de dados relacionais são objetos nomeados que contêm uma ou mais instruções dispostas e executadas pelo banco de dados em uma sequência quando chamadas. No exemplo mais básico, um procedimento armazenado pode salvar uma instrução comum em uma rotina reutilizável, como recuperar dados do banco de dados com filtros usados com frequência. Por exemplo, você pode criar um procedimento armazenado para recuperar os clientes da loja online que fizeram pedidos nos últimos meses. Nos cenários mais complexos, os procedimentos armazenados podem representar programas extensos que descrevem lógica de negócios complexa para aplicativos robustos.

O conjunto de instruções em um procedimento armazenado pode incluir instruções SQL comuns, como consultas INSERT, que retornam ou manipulam dados. Além disso, os procedimentos armazenados podem fazer uso de:

• Parâmetros passados para o procedimento armazenado ou retornados por meio dele.
• Variáveis declaradas para processar os dados recuperados diretamente no código do procedimento.
• Declarações condicionais, que permitem a execução de partes do código do procedimento armazenado dependendo de certas condições, como instruções IF ou CASE.
• Loops, como WHILE, LOOP e REPEAT, permitem executar partes do código várias vezes, como para cada linha em um conjunto de dados recuperado.
• Instruções de tratamento de erros, como retornar mensagens de erro aos usuários do banco de dados que acessam o procedimento.
• Chamadas para outros procedimentos armazenados no banco de dados.

Nota: A extensa sintaxe suportada pelo MySQL permite escrever programas robustos e resolver problemas complexos com procedimentos armazenados. Este guia abrange apenas o uso básico de procedimentos armazenados com instruções SQL incluídas no corpo do procedimento armazenado, entrada e parâmetros de saída. A execução de código condicional, usando variáveis, loops e tratamento de erros personalizado está fora do escopo deste guia. Incentivamos você a aprender mais sobre stored procedures na documentação oficial do MySQL.

Quando o procedimento é chamado por seu nome, o mecanismo de banco de dados o executa conforme definido, instrução por instrução.

O usuário do banco de dados deve ter as permissões apropriadas para executar o procedimento fornecido. Esse requisito de permissão fornece uma camada de segurança, impedindo o acesso direto ao banco de dados e, ao mesmo tempo, dando aos usuários acesso a procedimentos individuais que são seguros para execução.

Os procedimentos armazenados são executados diretamente no servidor de banco de dados, realizando todos os cálculos localmente e retornando os resultados para o usuário chamador somente quando concluídos.

Se você quiser alterar o comportamento do procedimento, poderá atualizar o procedimento no banco de dados e os aplicativos que o estiverem usando selecionarão automaticamente a nova versão. Todos os usuários começarão imediatamente a usar o novo código de procedimento sem precisar ajustar seus aplicativos.

Aqui está a estrutura geral do código SQL usado para criar um procedimento armazenado:

DELIMITER //
CREATE PROCEDURE procedure_name(parameter_1, parameter_2, . . ., parameter_n)
BEGIN
    instruction_1;
    instruction_2;
    . . .
    instruction_n;
END //
DELIMITER ;

A primeira e a última instrução neste fragmento de código são DELIMITER // e DELIMITER ;. Normalmente, o MySQL usa o símbolo de ponto e vírgula (;) para delimitar as instruções e indicar quando elas começam e terminam. Se você executar várias instruções no console do MySQL separadas por ponto e vírgula, elas serão tratadas como comandos separados e executadas independentemente, uma após a outra. No entanto, o procedimento armazenado pode incluir vários comandos que serão executados sequencialmente quando for chamado. Isso representa uma dificuldade ao tentar dizer ao MySQL para criar um novo procedimento. O mecanismo de banco de dados encontraria o sinal de ponto-e-vírgula no corpo do procedimento armazenado e pensaria que deveria parar de executar a instrução. Nesta situação, a instrução pretendida é todo o código de criação do procedimento, não uma única instrução dentro do próprio procedimento, portanto, o MySQL interpretaria mal suas intenções.

Para contornar essa limitação, use o comando DELIMITER para alterar temporariamente o delimitador de ; para // durante o CREATE PROCEDURE chamada. Em seguida, todos os pontos e vírgulas dentro do corpo do procedimento armazenado serão passados para o servidor como estão. Após o término de todo o procedimento, o delimitador é alterado novamente para ; com o último DELIMITER ;.

O coração do código para criar um novo procedimento é a chamada CREATE PROCEDURE seguida pelo nome do procedimento: procedure_name no exemplo. O nome do procedimento é seguido por uma lista opcional de parâmetros que o procedimento aceitará. A última parte é o corpo do procedimento, incluído nas instruções BEGIN e END. Dentro está o código do procedimento, que pode conter uma única instrução SQL, como uma consulta SELECT ou um código mais complexo.

O comando END termina com //, um delimitador temporário, em vez de um ponto e vírgula típico.

Na próxima seção, você criará um procedimento armazenado básico sem parâmetros envolvendo uma única consulta.

Criando um procedimento armazenado sem parâmetros

Nesta seção, você criará seu primeiro procedimento armazenado encapsulando uma única instrução SQL SELECT para retornar a lista de carros pertencentes ordenados por sua marca e valor em ordem decrescente.

Comece executando a instrução SELECT que você vai usar:

SELECT * FROM cars ORDER BY make, value DESC;

O banco de dados retornará a lista de carros da tabela cars, primeiro ordenados por marca e depois, dentro de uma única marca, por valor em ordem 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)

A Ferrari mais valiosa está no topo da lista, e o Porsche menos valioso aparece na parte inferior.

Suponha que essa consulta será usada com frequência em vários aplicativos ou por vários usuários e suponha que você deseja garantir que todos usem exatamente a mesma maneira de ordenar os resultados. Para fazer isso, você deseja criar um procedimento armazenado que salvará essa instrução em um procedimento nomeado reutilizável.

Para criar este procedimento armazenado, execute o seguinte fragmento de código:

DELIMITER //
CREATE PROCEDURE get_all_cars()
BEGIN
    SELECT * FROM cars ORDER BY make, value DESC;
END //
DELIMITER ;

Conforme descrito na seção anterior, o primeiro e o último comandos (DELIMITER // e DELIMITER ;) dizem ao MySQL para parar de tratar o caractere de ponto-e-vírgula como o delimitador de instrução pela duração de criação do procedimento.

O comando SQL CREATE PROCEDURE é seguido pelo nome do procedimento get_all_cars, que você pode definir para melhor descrever o que o procedimento faz. Após o nome do procedimento, há um par de parênteses () onde você pode adicionar parâmetros. Neste exemplo, o procedimento não usa parâmetros, então os parênteses estão vazios. Em seguida, entre os comandos BEGIN e END que definem o início e o fim do bloco de código do procedimento, a instrução SELECT usada anteriormente é escrita literalmente.

Nota: Dependendo de suas permissões de usuário do MySQL, você pode receber um erro ao executar o comando CREATE PROCEDURE: ERROR 1044 (42000): Acesso negado para o usuário sammy@ localhost para procedimentos de banco de dados. Para conceder permissões para criar e executar procedimentos armazenados para seu usuário, efetue login no MySQL como root e execute os seguintes comandos, substituindo o nome de usuário e host do MySQL conforme necessário:

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

Depois de atualizar as permissões do usuário, efetue logout como root, efetue login novamente como usuário e execute novamente a instrução CREATE PROCEDURE.

Você pode aprender mais sobre a aplicação de permissões relacionadas a procedimentos armazenados para usuários de banco de dados na documentação Rotinas armazenadas e privilégios do MySQL.

O banco de dados responderá com uma mensagem de sucesso:

Output
Query OK, 0 rows affected (0.02 sec)

O procedimento get_all_cars agora é salvo no banco de dados e, quando chamado, executará a instrução salva como está.

Para executar procedimentos armazenados salvos, você pode usar o comando SQL CALL seguido do nome do procedimento. Tente executar o procedimento recém-criado da seguinte forma:

CALL get_all_cars;

O nome do procedimento, get_all_cars, é tudo o que você precisa para usar o procedimento. Você não precisa mais digitar manualmente qualquer parte da instrução SELECT usada anteriormente. O banco de dados exibirá os resultados exatamente como a saída da instrução SELECT executada antes:

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)

Agora você criou com sucesso um procedimento armazenado sem nenhum parâmetro que retorna todos os carros da tabela cars ordenados de uma maneira específica. Você pode usar o procedimento em vários aplicativos.

Na próxima seção, você criará um procedimento que aceita parâmetros para alterar o comportamento do procedimento dependendo da entrada do usuário.

Criando um procedimento armazenado com um parâmetro de entrada

Nesta seção, você incluirá parâmetros de entrada para a definição do procedimento armazenado para permitir que os usuários que executam o procedimento passem dados para ele. Por exemplo, os usuários podem fornecer filtros de consulta.

O procedimento armazenado get_all_cars criado anteriormente recuperou todos os carros da tabela cars em todos os momentos. Vamos criar outro procedimento para encontrar carros de um determinado ano de fabricação. Para permitir isso, você definirá um parâmetro nomeado na definição do procedimento.

Execute o seguinte código:

DELIMITER //
CREATE PROCEDURE get_cars_by_year(
    IN year_filter int
)
BEGIN
    SELECT * FROM cars WHERE year = year_filter ORDER BY make, value DESC;
END //
DELIMITER ;

Há várias alterações no código de criação do procedimento da seção anterior.

Primeiro, o nome é get_cars_by_year, que descreve o procedimento: recuperar carros com base no ano de produção.

Os parênteses anteriormente vazios agora contêm uma única definição de parâmetro: IN year_filter int. A palavra-chave IN informa ao banco de dados que o parâmetro será passado pelo usuário que está chamando para o procedimento. O year_filter é um nome arbitrário para o parâmetro. Você o usará para se referir ao parâmetro no código do procedimento. Finalmente, int é o tipo de dados. Neste caso, o ano de produção é expresso como um valor numérico.

O parâmetro year_filter definido após o nome do procedimento aparece na instrução SELECT na cláusula WHERE year=year_filter, filtrando a tabela cars em relação ao ano de produção.

O banco de dados responderá mais uma vez com uma mensagem de sucesso:

Output
Query OK, 0 rows affected (0.02 sec)

Tente executar o procedimento sem passar nenhum parâmetro para ele, assim como você fez anteriormente:

CALL get_cars_by_year;

O banco de dados MySQL retornará uma mensagem de erro:

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

Desta vez, o procedimento armazenado espera que um parâmetro seja fornecido, mas nenhum foi fornecido. Para chamar um procedimento armazenado com parâmetros, você pode fornecer valores de parâmetro entre parênteses na mesma ordem esperada pelo procedimento. Para recuperar carros fabricados em 2017, execute:

CALL get_cars_by_year(2017);

Agora, o procedimento chamado será executado corretamente e retornará a lista de carros daquele ano:

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)

Neste exemplo, você aprendeu como passar parâmetros de entrada para procedimentos armazenados e usá-los em consultas dentro de um procedimento para fornecer opções de filtragem.

Na próxima seção, você usará parâmetros de saída para criar procedimentos que retornam vários valores diferentes em uma única execução.

Criando um procedimento armazenado com parâmetros de entrada e saída

Em ambos os exemplos anteriores, os procedimentos armazenados que você criou chamavam uma instrução SELECT para obter um conjunto de resultados. Mas, em alguns casos, você pode precisar de um procedimento armazenado que retorne vários valores diferentes juntos, em vez de um único conjunto de resultados para uma consulta individual.

Suponha que você queira criar um procedimento que forneça informações resumidas sobre os carros de um determinado ano, incluindo a quantidade de carros da coleção e seu valor de mercado (mínimo, máximo e médio).

Para fazer isso, você pode usar os parâmetros OUT ao criar um novo procedimento armazenado. Semelhante aos parâmetros IN, os parâmetros OUT têm nomes e tipos de dados associados a eles. No entanto, em vez de passar dados para o procedimento armazenado, eles podem ser preenchidos com dados pelo procedimento armazenado para retornar valores ao usuário chamador.

Crie um procedimento get_car_stats_by_year que retornará dados resumidos sobre os carros de um determinado ano de produção usando parâmetros de saída:

DELIMITER //
CREATE PROCEDURE get_car_stats_by_year(
    IN year_filter int,
    OUT cars_number int,
    OUT min_value decimal(10, 2),
    OUT avg_value decimal(10, 2),
    OUT max_value decimal(10, 2)
)
BEGIN
    SELECT COUNT(*), MIN(value), AVG(value), MAX(value)
    INTO cars_number, min_value, avg_value, max_value
    FROM cars
    WHERE year = year_filter ORDER BY make, value DESC;
END //
DELIMITER ;

Desta vez, juntamente com o parâmetro IN year_filter usado para filtrar carros pelo ano de produção, quatro parâmetros OUT são definidos dentro do bloco de parênteses. O parâmetro cars_number é representado com o tipo de dados int e será usado para retornar o número de carros na coleção. Os parâmetros min_value, avg_value e max_value representam valor de mercado e são definidos com o tipo decimal(10, 2) (semelhante à coluna value na tabela cars). Estes serão usados para retornar informações sobre os carros mais baratos e mais caros da coleção, bem como o preço médio de todos os carros correspondentes.

A instrução SELECT consulta quatro valores da tabela cars usando funções matemáticas SQL: COUNT para obter o número total de carros e MIN , AVG e MAX para obter o valor mínimo, médio e máximo da coluna valor.

Observação:

Para informar ao banco de dados que os resultados dessa consulta devem ser armazenados nos parâmetros de saída do procedimento armazenado, uma nova palavra-chave, INTO, é introduzida. Após a palavra-chave INTO, são listados os nomes de quatro parâmetros de procedimento correspondentes aos dados recuperados. Com isso, o MySQL salvará o valor COUNT(*) no parâmetro cars_number, o MIN(value) result no parâmetro min_value e assim por diante.

O banco de dados confirmará a criação bem-sucedida do procedimento:

Output
Query OK, 0 rows affected (0.02 sec)

Agora, execute o novo procedimento executando:

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

Os quatro novos parâmetros começam com o sinal @. Esses são nomes de variáveis locais no console do MySQL que você pode usar para armazenar dados temporariamente. Quando você os passa para o procedimento armazenado que acabou de criar, o procedimento insere valores nessas variáveis.

O banco de dados responderá com:

Output
Query OK, 1 row affected (0.00 sec)

Isso é diferente do comportamento anterior, onde os resultados eram exibidos imediatamente na tela. Isso ocorre porque os resultados do procedimento armazenado foram salvos em parâmetros de saída e não retornados como um resultado de consulta. Para acessar os resultados, você pode SELECT diretamente no shell do MySQL da seguinte forma:

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

Com esta consulta, você está selecionando valores das variáveis locais, não chamando o procedimento novamente. O procedimento armazenado salvou seus resultados nessas variáveis e os dados permanecerão disponíveis até você se desconectar do shell.

Observação:

A saída exibirá os valores para as variáveis consultadas:

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

Os valores correspondem ao número de carros produzidos em 2017, bem como ao valor mínimo, médio e máximo de mercado dos carros desse ano de produção.

Neste exemplo, você aprendeu a usar parâmetros de saída para retornar vários valores diferentes de dentro do procedimento armazenado para uso posterior. Na próxima seção, você aprenderá como remover procedimentos criados.

Removendo Procedimentos Armazenados

Nesta seção, você removerá os procedimentos armazenados que estão presentes no banco de dados.

Às vezes, o procedimento que você criou pode não ser mais necessário. Em outras circunstâncias, talvez você queira alterar a maneira como o procedimento funciona. O MySQL não permite alterar a definição do procedimento após a criação, portanto, a única maneira de fazer isso é remover o procedimento primeiro e recriá-lo com as alterações desejadas.

Vamos remover o último procedimento, get_car_stats_by_year. Para fazer isso, você pode usar a instrução DROP PROCEDURE:

DROP PROCEDURE get_car_stats_by_year;

O banco de dados confirmará a exclusão bem-sucedida do procedimento com uma mensagem de sucesso:

Output
Query OK, 0 rows affected (0.02 sec)

Você pode verificar se o procedimento foi excluído tentando chamá-lo. Executar:

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

Desta vez, você verá uma mensagem de erro dizendo que o procedimento não está presente no banco de dados:

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

Nesta seção, você aprendeu como excluir procedimentos armazenados existentes no banco de dados.

Conclusão

Seguindo este guia, você aprendeu o que são procedimentos armazenados e como usá-los no MySQL para salvar instruções reutilizáveis em procedimentos nomeados e executá-los posteriormente. Você criou procedimentos armazenados sem parâmetros e procedimentos que usam parâmetros de entrada e saída para torná-los mais flexíveis.

Você pode usar procedimentos armazenados para criar rotinas reutilizáveis e unificar métodos para acessar dados em vários aplicativos, bem como implementar comportamentos complexos que excedem as possibilidades oferecidas por consultas SQL individuais. Este tutorial cobriu apenas o básico do uso de procedimentos armazenados. Para saber mais sobre isso, consulte a documentação do MySQL sobre stored procedures.

Se você quiser aprender mais sobre os diferentes conceitos da linguagem SQL e como trabalhar com ela, recomendamos que verifique os outros guias da série Como usar o SQL.