Guia Completo de Parâmetros em Procedimentos Armazenados SQL: Como Usar e Melhores Práticas

O uso de parâmetros em procedimentos armazenados SQL permite manipular dados de forma eficiente e flexível. Procedimentos armazenados são uma ferramenta poderosa para simplificar operações complexas dentro do banco de dados, melhorando a reutilização e a manutenção. Neste artigo, vamos explorar em detalhes os tipos de parâmetros, como declará-los, exemplos práticos, tratamento de erros, e tudo o que você precisa saber sobre parâmetros em procedimentos armazenados.

Fundamentos dos Procedimentos Armazenados

Procedimentos armazenados são conjuntos de instruções SQL que podem ser executados dentro do banco de dados, semelhantes a uma função que pode ser chamada conforme necessário. Isso permite processar consultas complexas e tarefas repetitivas de maneira eficiente, melhorando a reutilização e a manutenção. Procedimentos armazenados também contribuem para a otimização de desempenho e fortalecimento da segurança.

Vantagens dos Procedimentos Armazenados

As principais vantagens de usar procedimentos armazenados incluem:

1. Reutilização: Uma vez criado, o procedimento pode ser reutilizado quantas vezes forem necessárias.
2. Desempenho: Por serem pré-compilados, os procedimentos armazenados têm uma execução mais rápida.
3. Segurança: Ao invés de executar consultas SQL diretamente, o uso de procedimentos reduz o risco de injeções SQL.
4. Manutenção: Centralizar a lógica em um único lugar facilita a manutenção.

Sintaxe Básica de Procedimentos Armazenados

Abaixo está a sintaxe básica para um procedimento armazenado no SQL Server:

CREATE PROCEDURE ProcedureName
AS
BEGIN
    -- Insira suas instruções SQL aqui
END;

Como exemplo, vamos criar um procedimento armazenado simples que recupera dados da tabela de funcionários.

CREATE PROCEDURE GetEmployees
AS
BEGIN
    SELECT * FROM Employees;
END;

Este procedimento armazenado, ao ser executado, recupera todos os registros da tabela de funcionários.

Tipos e Características dos Parâmetros

Os procedimentos armazenados podem usar vários parâmetros para permitir a manipulação flexível dos dados. Existem três tipos de parâmetros: de entrada, de saída e de entrada/saída. Vamos explorar as características e usos de cada um.

Parâmetros de Entrada

Parâmetros de entrada são usados para passar valores ao procedimento armazenado. Eles recebem valores do chamador e realizam o processamento com base nesses valores. A declaração usa a palavra-chave IN.

Exemplo:

CREATE PROCEDURE GetEmployeeByID
    @EmployeeID INT
AS
BEGIN
    SELECT * FROM Employees WHERE EmployeeID = @EmployeeID;
END;

Neste exemplo, o parâmetro de entrada @EmployeeID é usado para recuperar informações de um funcionário específico.

Parâmetros de Saída

Parâmetros de saída são usados para retornar os resultados da execução do procedimento armazenado ao chamador. A declaração usa a palavra-chave OUT.

Exemplo:

CREATE PROCEDURE GetEmployeeCount
    @EmployeeCount INT OUTPUT
AS
BEGIN
    SELECT @EmployeeCount = COUNT(*) FROM Employees;
END;

Neste exemplo, o parâmetro de saída @EmployeeCount é usado para obter o número de funcionários e retorná-lo ao chamador.

Parâmetros de Entrada/Saída

Parâmetros de entrada/saída são usados para passar valores ao procedimento armazenado e retornar valores atualizados após o processamento. A declaração usa a palavra-chave INOUT.

Exemplo:

CREATE PROCEDURE UpdateEmployeeSalary
    @EmployeeID INT,
    @NewSalary DECIMAL(10, 2) OUTPUT
AS
BEGIN
    UPDATE Employees SET Salary = @NewSalary WHERE EmployeeID = @EmployeeID;
    SELECT @NewSalary = Salary FROM Employees WHERE EmployeeID = @EmployeeID;
END;

Neste exemplo, o parâmetro de entrada/saída @NewSalary é usado para atualizar o salário de um funcionário e retornar o salário atualizado.

Declaração e Uso de Parâmetros

Vamos explicar como declarar e usar parâmetros em procedimentos armazenados com exemplos práticos. Declarar e usar corretamente os parâmetros pode aumentar significativamente a flexibilidade e a reutilização dos procedimentos armazenados.

Declaração de Parâmetros

Ao declarar parâmetros em um procedimento armazenado, você deve especificar o nome do parâmetro, o tipo de dados e, opcionalmente, a direção (entrada, saída, entrada/saída).

Sintaxe básica:

CREATE PROCEDURE ProcedureName
    @ParameterName DataType [IN | OUT | INOUT]
AS
BEGIN
    -- Insira suas instruções SQL aqui
END;

Exemplo:

CREATE PROCEDURE GetEmployeeByName
    @EmployeeName NVARCHAR(50)
AS
BEGIN
    SELECT * FROM Employees WHERE Name = @EmployeeName;
END;

Neste exemplo, o parâmetro @EmployeeName é declarado para procurar dados de funcionários com base no nome.

Uso de Parâmetros

Os parâmetros declarados podem ser usados como variáveis normais dentro do procedimento armazenado. Você pode atribuir valores a esses parâmetros e usá-los em instruções SQL.

Exemplo:

CREATE PROCEDURE UpdateEmployeeDepartment
    @EmployeeID INT,
    @NewDepartmentID INT
AS
BEGIN
    UPDATE Employees SET DepartmentID = @NewDepartmentID WHERE EmployeeID = @EmployeeID;
END;

Este procedimento armazenado usa dois parâmetros de entrada, @EmployeeID e @NewDepartmentID, para atualizar o departamento de um funcionário.

Exemplo de Uso de Parâmetros: Inserção de Dados

Veja um exemplo de como usar parâmetros para inserir dados.

Exemplo:

CREATE PROCEDURE AddNewEmployee
    @EmployeeName NVARCHAR(50),
    @HireDate DATE,
    @DepartmentID INT
AS
BEGIN
    INSERT INTO Employees (Name, HireDate, DepartmentID)
    VALUES (@EmployeeName, @HireDate, @DepartmentID);
END;

Este procedimento armazenado insere as informações de um novo funcionário na tabela Employees.

Tipos de Dados de Parâmetros

Há uma variedade de tipos de dados que podem ser usados para parâmetros em procedimentos armazenados. Escolher o tipo de dados correto permite operações eficientes e precisas. Aqui, discutiremos os principais tipos de dados e como escolhê-los.

Tipos de Dados Básicos

Abaixo estão os tipos de dados mais comuns usados em procedimentos armazenados.

• INT: Armazena valores inteiros. Exemplo: idade, ID.
• DECIMAL: Armazena números com casas decimais. Exemplo: preço, salário.
• NVARCHAR: Armazena cadeias de texto de comprimento variável. Exemplo: nome, endereço.
• DATE: Armazena datas. Exemplo: aniversário, data de contratação.

Escolhendo o Tipo de Dados Correto

Ao escolher o tipo de dados para um parâmetro, considere os seguintes pontos.

Natureza dos Dados

Escolha um tipo de dados adequado à natureza dos dados. Por exemplo, use INT para quantidades ou contagens, DECIMAL para preços ou percentuais, e NVARCHAR para informações de texto.

Eficiência de Armazenamento

A escolha do tipo de dados também afeta a eficiência de armazenamento. Selecionar o tamanho apropriado para o tipo de dados pode minimizar o uso de armazenamento. Por exemplo, use NVARCHAR(50) para cadeias de texto curtas.

Precisão dos Dados

Para dados numéricos, escolha um tipo de dados que ofereça a precisão e escala necessárias. Por exemplo, para valores monetários, use DECIMAL(10, 2) para garantir duas casas decimais.

Exemplo Prático: Escolhendo o Tipo de Dados de Parâmetros

No exemplo a seguir, são escolhidos tipos de dados apropriados para gerenciar informações de funcionários em um procedimento armazenado.

CREATE PROCEDURE AddEmployee
    @EmployeeName NVARCHAR(100),
    @BirthDate DATE,
    @Salary DECIMAL(10, 2),
    @DepartmentID INT
AS
BEGIN
    INSERT INTO Employees (Name, BirthDate, Salary, DepartmentID)
    VALUES (@EmployeeName, @BirthDate, @Salary, @DepartmentID);
END;

Neste exemplo, usamos NVARCHAR(100) para o nome do funcionário, DATE para a data de nascimento, DECIMAL(10, 2) para o salário e INT para o ID do departamento.

Uso de Parâmetros em Condições

O uso de parâmetros em procedimentos armazenados para criar condições permite a criação de consultas flexíveis e poderosas. Aqui, vamos explorar os métodos básicos e exemplos práticos de uso de condições.

Condições Básicas

Você pode usar a instrução IF para executar diferentes operações com base no valor dos parâmetros.

Exemplo:

CREATE PROCEDURE GetEmployeeDetails
    @EmployeeID INT,
    @IncludeSalary BIT
AS
BEGIN
    IF @IncludeSalary = 1
    BEGIN
        SELECT Name, BirthDate, Salary FROM Employees WHERE EmployeeID = @EmployeeID;
    END
    ELSE
    BEGIN
        SELECT Name, BirthDate FROM Employees WHERE EmployeeID = @EmployeeID;
    END
END;

Neste procedimento armazenado, o parâmetro @IncludeSalary determina se as informações de salário serão incluídas na consulta.

Condições Complexas

Você pode combinar várias condições para implementar uma lógica mais complexa.

Exemplo:

CREATE PROCEDURE FilterEmployees
    @DepartmentID INT = NULL,
    @MinSalary DECIMAL(10, 2) = NULL,
    @MaxSalary DECIMAL(10, 2) = NULL
AS
BEGIN
    SELECT * FROM Employees
    WHERE (@DepartmentID IS NULL OR DepartmentID = @DepartmentID)
    AND (@MinSalary IS NULL OR Salary >= @MinSalary)
    AND (@MaxSalary IS NULL OR Salary <= @MaxSalary);
END;

Neste exemplo, os parâmetros @DepartmentID, @MinSalary e @MaxSalary são usados para filtrar os funcionários. Se o parâmetro for NULL, a condição correspondente será ignorada.

Exemplo Prático: Atualização de Dados Usando Condições

No exemplo a seguir, parâmetros são usados para atualizar informações de funcionários com base em condições específicas.

Exemplo:

CREATE PROCEDURE UpdateEmployeeInfo
    @EmployeeID INT,
    @NewName NVARCHAR(100) = NULL,
    @NewDepartmentID INT = NULL,
    @NewSalary DECIMAL(10, 2) = NULL
AS
BEGIN
    IF @NewName IS NOT NULL
    BEGIN
        UPDATE Employees SET Name = @NewName WHERE EmployeeID = @EmployeeID;
    END

    IF @NewDepartmentID IS NOT NULL
    BEGIN
        UPDATE Employees SET DepartmentID = @NewDepartmentID WHERE EmployeeID = @EmployeeID;
    END

    IF @NewSalary IS NOT NULL
    BEGIN
        UPDATE Employees SET Salary = @NewSalary WHERE EmployeeID = @EmployeeID;
    END
END;

Este procedimento armazenado atualiza as informações de um funcionário com base nos parâmetros @NewName, @NewDepartmentID e @NewSalary. Apenas os campos que não são NULL são atualizados.

Uso de Múltiplos Parâmetros

Usar múltiplos parâmetros em procedimentos armazenados permite executar consultas mais flexíveis e complexas. Aqui, vamos discutir as melhores práticas e como usar múltiplos parâmetros de forma eficaz.

Noções Básicas sobre Múltiplos Parâmetros

Para adicionar múltiplos parâmetros a um procedimento armazenado, basta declará-los separados por vírgulas.

Sintaxe básica:

CREATE PROCEDURE ProcedureName
    @Parameter1 DataType,
    @Parameter2 DataType,
    ...
AS
BEGIN
    -- Insira suas instruções SQL aqui
END;

Exemplo:

CREATE PROCEDURE GetEmployeeInfo
    @EmployeeID INT,
    @DepartmentID INT
AS
BEGIN
    SELECT * FROM Employees WHERE EmployeeID = @EmployeeID AND DepartmentID = @DepartmentID;
END;

Neste exemplo, dois parâmetros, @EmployeeID e @DepartmentID, são usados para recuperar informações de um funcionário específico.

Valores Padrão para Parâmetros

Definir valores padrão para parâmetros permite que você omita o valor ao chamar o procedimento.

Exemplo:

CREATE PROCEDURE GetEmployeesByDepartment
    @DepartmentID INT = NULL
AS
BEGIN
    IF @DepartmentID IS NULL
    BEGIN
        SELECT * FROM Employees;
    END
    ELSE
    BEGIN
        SELECT * FROM Employees WHERE DepartmentID = @DepartmentID;
    END
END;

Neste procedimento armazenado, se @DepartmentID não for especificado, todos os funcionários serão recuperados; caso contrário, apenas os funcionários do departamento especificado serão retornados.

Ordem e Especificação dos Parâmetros

Ao chamar um procedimento armazenado, a ordem dos parâmetros deve ser considerada. Especificar os nomes dos parâmetros permite chamá-los fora de ordem.

Exemplo:

EXEC GetEmployeeInfo @EmployeeID = 1, @DepartmentID = 2;

Nesta chamada, os nomes dos parâmetros são especificados, permitindo que sejam passados na ordem desejada.

Exemplo Prático: Inserção de Dados Usando Múltiplos Parâmetros

No exemplo a seguir, múltiplos parâmetros são usados para inserir informações de um novo funcionário.

Exemplo:

CREATE PROCEDURE AddEmployee
    @EmployeeName NVARCHAR(100),
    @BirthDate DATE,
    @Salary DECIMAL(10, 2),
    @DepartmentID INT
AS
BEGIN
    INSERT INTO Employees (Name, BirthDate, Salary, DepartmentID)
    VALUES (@EmployeeName, @BirthDate, @Salary, @DepartmentID);
END;

Este procedimento armazenado usa quatro parâmetros, @EmployeeName, @BirthDate, @Salary e @DepartmentID, para inserir informações de um novo funcionário.

Exemplo Prático: Geração de SQL Dinâmico

O uso de parâmetros para gerar SQL dinâmico permite a criação de consultas flexíveis e reutilizáveis. No entanto, ao usar SQL dinâmico, é importante estar ciente dos riscos de injeção de SQL e adotar medidas de segurança apropriadas.

Sintaxe Básica de SQL Dinâmico

Para usar SQL dinâmico, você pode usar EXEC ou sp_executesql para executar instruções SQL. sp_executesql é preferível porque permite a execução de consultas parametrizadas, o que melhora a segurança.

Exemplo:

CREATE PROCEDURE SearchEmployees
    @SearchTerm NVARCHAR(100)
AS
BEGIN
    DECLARE @SQL NVARCHAR(MAX)
    SET @SQL = 'SELECT * FROM Employees WHERE Name LIKE @Term'

    EXEC sp_executesql @SQL, N'@Term NVARCHAR(100)', @Term = '%' + @SearchTerm + '%'
END;

Este procedimento armazenado usa o parâmetro @SearchTerm para procurar registros de funcionários que correspondam parcialmente ao nome.

Vantagens e Considerações sobre SQL Dinâmico

As vantagens do uso de SQL dinâmico incluem:

• Flexibilidade: Permite modificar a consulta dinamicamente durante a execução.
• Reutilização: A mesma consulta básica pode ser reutilizada em diferentes condições.

Considerações:

• Risco de injeção de SQL: O uso de entrada de usuário diretamente no SQL dinâmico pode expor o sistema a ataques de injeção de SQL, por isso é importante usar consultas parametrizadas.
• Desempenho: O SQL dinâmico pode ter desempenho inferior ao SQL estático.

Exemplo Prático: Geração de SQL Dinâmico com Múltiplas Condições

No exemplo a seguir, múltiplos parâmetros são usados para gerar SQL dinâmico com base em várias condições.

Exemplo:

CREATE PROCEDURE FilterEmployees
    @Name NVARCHAR(100) = NULL,
    @MinSalary DECIMAL(10, 2) = NULL,
    @MaxSalary DECIMAL(10, 2) = NULL
AS
BEGIN
    DECLARE @SQL NVARCHAR(MAX)
    SET @SQL = 'SELECT * FROM Employees WHERE 1=1'

    IF @Name IS NOT NULL
    BEGIN
        SET @SQL = @SQL + ' AND Name LIKE @Name'
    END

    IF @MinSalary IS NOT NULL
    BEGIN
        SET @SQL = @SQL + ' AND Salary >= @MinSalary'
    END

    IF @MaxSalary IS NOT NULL
    BEGIN
        SET @SQL = @SQL + ' AND Salary <= @MaxSalary'
    END

    EXEC sp_executesql @SQL,
        N'@Name NVARCHAR(100), @MinSalary DECIMAL(10, 2), @MaxSalary DECIMAL(10, 2)',
        @Name = '%' + @Name + '%',
        @MinSalary = @MinSalary,
        @MaxSalary = @MaxSalary
END;

Neste procedimento armazenado, os parâmetros @Name, @MinSalary e @MaxSalary são usados para filtrar os funcionários. Cada condição é adicionada dinamicamente.

Validação de Parâmetros e Tratamento de Erros

Ao usar parâmetros em procedimentos armazenados, é importante validar os valores dos parâmetros e implementar um tratamento de erros adequado. Isso garante a consistência e a confiabilidade dos dados.

Validação de Parâmetros

Validar os valores dos parâmetros dentro do procedimento armazenado ajuda a evitar dados incorretos e erros inesperados.

Exemplo:

CREATE PROCEDURE UpdateEmployeeSalary
    @EmployeeID INT,
    @NewSalary DECIMAL(10, 2)
AS
BEGIN
    -- Validação de parâmetros
    IF @EmployeeID <= 0
    BEGIN
        RAISERROR('EmployeeID deve ser maior que 0', 16, 1)
        RETURN
    END

    IF @NewSalary < 0
    BEGIN
        RAISERROR('Salário não pode ser negativo', 16, 1)
        RETURN
    END

    -- Atualização
    UPDATE Employees SET Salary = @NewSalary WHERE EmployeeID = @EmployeeID;
END;

Neste procedimento armazenado, é validado se @EmployeeID é um inteiro positivo e se @NewSalary não é negativo. Caso essas condições não sejam atendidas, um erro é gerado e a execução é interrompida.

Tratamento de Erros

É importante tratar adequadamente os erros que podem ocorrer dentro de um procedimento armazenado. Um método comum é o uso de blocos TRY...CATCH.

Exemplo:

CREATE PROCEDURE TransferEmployee
    @EmployeeID INT,
    @NewDepartmentID INT
AS
BEGIN
    BEGIN TRY
        -- Início da transação
        BEGIN TRANSACTION

        -- Atualização do departamento
        UPDATE Employees SET DepartmentID = @NewDepartmentID WHERE EmployeeID = @EmployeeID;

        -- Commit
        COMMIT TRANSACTION
    END TRY
    BEGIN CATCH
        -- Rollback
        ROLLBACK TRANSACTION

        -- Captura da mensagem de erro
        DECLARE @ErrorMessage NVARCHAR(4000)
        SELECT @ErrorMessage = ERROR_MESSAGE()

        -- Geração do erro
        RAISERROR(@ErrorMessage, 16, 1)
    END CATCH
END;

Neste procedimento armazenado, uma transação é iniciada para atualizar o departamento de um funcionário. Se ocorrer um erro, a transação é revertida e a mensagem de erro é exibida.

Exemplo Prático: Combinação de Validação de Parâmetros e Tratamento de Erros

No exemplo a seguir, a validação de parâmetros e o tratamento de erros são combinados para criar um procedimento armazenado robusto.

Exemplo:

CREATE PROCEDURE PromoteEmployee
    @EmployeeID INT,
    @NewTitle NVARCHAR(100),
    @NewSalary DECIMAL(10, 2)
AS
BEGIN
    BEGIN TRY
        -- Validação de parâmetros
        IF @EmployeeID <= 0
        BEGIN
            RAISERROR('EmployeeID deve ser maior que 0', 16, 1)
            RETURN
        END

        IF @NewSalary < 0
        BEGIN
            RAISERROR('Salário não pode ser negativo', 16, 1)
            RETURN
        END

        -- Início da transação
        BEGIN TRANSACTION

        -- Promoção do funcionário
        UPDATE Employees SET Title = @NewTitle, Salary = @NewSalary WHERE EmployeeID = @EmployeeID;

        -- Commit
        COMMIT TRANSACTION
    END TRY
    BEGIN CATCH
        -- Rollback
        ROLLBACK TRANSACTION

        -- Captura da mensagem de erro
        DECLARE @ErrorMessage NVARCHAR(4000)
        SELECT @ErrorMessage = ERROR_MESSAGE()

        -- Geração do erro
        RAISERROR(@ErrorMessage, 16, 1)
    END CATCH
END;

Este procedimento armazenado valida o ID do funcionário e o valor do novo salário, executa a promoção em uma transação e trata erros que possam ocorrer durante o processo.

Exemplo Prático: Processamento em Lote com Procedimentos Armazenados

Procedimentos armazenados são uma ferramenta poderosa para executar processamento em lote de maneira eficiente. Ao manipular grandes volumes de dados de uma só vez, o uso de procedimentos armazenados melhora o desempenho e a reutilização de código.

Conceito Básico de Processamento em Lote

Processamento em lote refere-se à execução de grandes volumes de dados de uma só vez, incluindo operações de inserção, atualização e exclusão. Isso permite manipular dados de maneira mais eficiente do que processá-los individualmente.

Vantagens do Processamento em Lote

• Melhor Desempenho: Processar grandes volumes de dados de uma só vez é mais rápido do que processá-los individualmente.
• Consistência: O uso de transações garante a consistência dos dados.
• Reutilização: A mesma operação pode ser executada repetidamente, aumentando a reutilização do código.

Exemplo de Processamento em Lote: Atualização de Salários de Funcionários

No procedimento armazenado abaixo, os salários dos funcionários são atualizados em lote com base em condições especificadas.

Exemplo:

CREATE PROCEDURE UpdateSalariesBatch
    @DepartmentID INT,
    @SalaryIncrease DECIMAL(10, 2)
AS
BEGIN
    BEGIN TRY
        -- Início da transação
        BEGIN TRANSACTION

        -- Atualização dos salários dos funcionários do departamento especificado
        UPDATE Employees
        SET Salary = Salary + @SalaryIncrease
        WHERE DepartmentID = @DepartmentID;

        -- Commit
        COMMIT TRANSACTION
    END TRY
    BEGIN CATCH
        -- Rollback
        ROLLBACK TRANSACTION

        -- Captura da mensagem de erro
        DECLARE @ErrorMessage NVARCHAR(4000)
        SELECT @ErrorMessage = ERROR_MESSAGE()

        -- Geração do erro
        RAISERROR(@ErrorMessage, 16, 1)
    END CATCH
END;

Este procedimento armazenado atualiza os salários de todos os funcionários de um departamento específico. Uma transação é usada para garantir a consistência e, em caso de erro, a transação é revertida.

Exemplo de Processamento em Lote: Inserção de Dados em Massa

No procedimento armazenado abaixo, grandes volumes de dados são inseridos de uma só vez, lendo os dados de outra tabela.

Exemplo:

CREATE PROCEDURE InsertNewEmployeesBatch
AS
BEGIN
    BEGIN TRY
        -- Início da transação
        BEGIN TRANSACTION

        -- Inserção em massa de novos funcionários
        INSERT INTO Employees (Name, BirthDate, Salary, DepartmentID)
        SELECT Name, BirthDate, Salary, DepartmentID
        FROM NewEmployees;

        -- Commit
        COMMIT TRANSACTION
    END TRY
    BEGIN CATCH
        -- Rollback
        ROLLBACK TRANSACTION

        -- Captura da mensagem de erro
        DECLARE @ErrorMessage NVARCHAR(4000)
        SELECT @ErrorMessage = ERROR_MESSAGE()

        -- Geração do erro
        RAISERROR(@ErrorMessage, 16, 1)
    END CATCH
END;

Este procedimento armazenado lê dados da tabela NewEmployees e os insere em massa na tabela Employees. Uma transação é usada para garantir a consistência, revertendo a operação em caso de erro.

Exercícios Práticos

Para aprofundar seus conhecimentos e aprimorar suas habilidades práticas, aqui estão alguns exercícios. Eles ajudarão você a entender melhor o uso de parâmetros em procedimentos armazenados e a aplicação de processamento em lote.

Exercício 1: Criação de um Procedimento Armazenado Básico

Crie um procedimento armazenado básico com base nos seguintes requisitos:

• Receba EmployeeID como um parâmetro de entrada e recupere os detalhes desse funcionário.
• As informações do funcionário devem incluir Name, BirthDate e DepartmentID.

Solução Sugerida

CREATE PROCEDURE GetEmployeeDetails
    @EmployeeID INT
AS
BEGIN
    SELECT Name, BirthDate, DepartmentID
    FROM Employees
    WHERE EmployeeID = @EmployeeID;


END;

Exercício 2: Criação de um Procedimento Armazenado com Condições

Crie um procedimento armazenado com condições, com base nos seguintes requisitos:

• Receba DepartmentID e MinSalary como parâmetros de entrada e filtre os funcionários com base nessas condições.
• Se DepartmentID for nulo, procure em todos os departamentos.
• Se MinSalary for nulo, não aplique a condição de salário.

Solução Sugerida

CREATE PROCEDURE FilterEmployees
    @DepartmentID INT = NULL,
    @MinSalary DECIMAL(10, 2) = NULL
AS
BEGIN
    SELECT * FROM Employees
    WHERE (@DepartmentID IS NULL OR DepartmentID = @DepartmentID)
    AND (@MinSalary IS NULL OR Salary >= @MinSalary);
END;

Exercício 3: Criação de um Procedimento Armazenado com Tratamento de Erros

Crie um procedimento armazenado que inclua tratamento de erros com base nos seguintes requisitos:

• Receba EmployeeID e NewSalary como parâmetros de entrada para atualizar o salário de um funcionário.
• Gere um erro se EmployeeID for menor ou igual a 0 ou se NewSalary for negativo.
• Use uma transação para garantir a consistência.

Solução Sugerida

CREATE PROCEDURE UpdateEmployeeSalary
    @EmployeeID INT,
    @NewSalary DECIMAL(10, 2)
AS
BEGIN
    BEGIN TRY
        -- Validação de parâmetros
        IF @EmployeeID <= 0
        BEGIN
            RAISERROR('EmployeeID deve ser maior que 0', 16, 1)
            RETURN
        END

        IF @NewSalary < 0
        BEGIN
            RAISERROR('Salário não pode ser negativo', 16, 1)
            RETURN
        END

        -- Início da transação
        BEGIN TRANSACTION

        -- Atualização do salário do funcionário
        UPDATE Employees SET Salary = @NewSalary WHERE EmployeeID = @EmployeeID;

        -- Commit
        COMMIT TRANSACTION
    END TRY
    BEGIN CATCH
        -- Rollback
        ROLLBACK TRANSACTION

        -- Captura da mensagem de erro
        DECLARE @ErrorMessage NVARCHAR(4000)
        SELECT @ErrorMessage = ERROR_MESSAGE()

        -- Geração do erro
        RAISERROR(@ErrorMessage, 16, 1)
    END CATCH
END;

Conclusão

O uso de parâmetros em procedimentos armazenados SQL melhora significativamente a eficiência e a flexibilidade das operações de dados. Neste artigo, abordamos desde os tipos de parâmetros e como declará-los até exemplos práticos, tratamento de erros e aplicação em processamento em lote. Use esses conhecimentos para realizar operações de banco de dados mais complexas e eficientes. O uso adequado de parâmetros permite criar código SQL seguro e de fácil manutenção.