Consideramos uma situação em que os procedimentos armazenados podem degradar o desempenho da consulta.
Ao compilar procedimentos armazenados no MS SQL Server 2000, os procedimentos armazenados são colocados no cache do procedimento, o que pode ajudar a aumentar o desempenho quando executados, eliminando a necessidade de análise, otimização e compilação do código do procedimento armazenado.
Por outro lado, existem armadilhas no armazenamento do código compilado de um procedimento armazenado que podem ter o efeito oposto.
O fato é que ao compilar um procedimento armazenado, o plano de execução das instruções que compõem o código do procedimento é compilado, respectivamente, se o procedimento armazenado compilado estiver armazenado em cache, seu plano de execução também será armazenado em cache e, portanto, o procedimento armazenado não será ser otimizado para uma situação específica e parâmetros de consulta.
Farei um pequeno experimento para demonstrar isso.
PASSO 1. Criação de banco de dados.
Para o experimento, vamos criar um banco de dados separado.
CRIAR BANCO DE DADOS test_sp_perf
ATIVADO (NAME="test_data", FILENAME="c:\temp\test_data", SIZE=1, MAXSIZE=10,FILEGROWTH=1Mb)
LOG ON (NAME="test_log", FILENAME="c:\temp\test_log", SIZE=1, MAXSIZE=10,FILEGROWTH=1Mb)
PASSO 2. Criando uma tabela.
CREATE TABLE sp_perf_test(column1 int, column2 char(5000))
ETAPA 3. Preenchendo a tabela com strings de teste. Linhas duplicadas são adicionadas intencionalmente à tabela. 10.000 linhas com números de 1 a 10.000 e 10.000 linhas com números de 50.000.
DECLARE @i int
SET @i=1
Enquanto eu<10000)
COMEÇAR
INSERT INTO sp_perf_test(column1, column2) VALUES(@i,"Test string #"+CAST(@i as char(8)))
INSERT INTO sp_perf_test(column1, column2) VALUES(50000,"Sequência de teste #"+CAST(@i as char(8)))
SET @i= @i+1
FIM
SELECT COUNT(*) FROM sp_perf_test
VAI
PASSO 4. Crie um índice não clusterizado. Como o plano de execução é armazenado em cache com o procedimento, o índice será usado da mesma maneira para todas as chamadas.
CRIAR ÍNDICE NÃO CLUSTERADO CL_perf_test ON sp_perf_test(column1)
VAI
PASSO 5. Crie um procedimento armazenado. O procedimento simplesmente executa a instrução SELECT com a condição.
CREATE PROC proc1 (@paramint)
COMO
SELECT coluna1, coluna2 FROM sp_perf_test WHERE [e-mail protegido]
VAI
PASSO 6. Execute um procedimento armazenado. Ao iniciar um procedimento vulnerável, um parâmetro seletivo é usado especificamente. Como resultado do procedimento, obtemos 1 linha. O plano de execução indica o uso de um índice não clusterizado, como a consulta é seletiva e esta é a melhor maneira de extrair a string. Um procedimento otimizado para buscar uma única linha é armazenado no cache de procedimento.
EXEC proc1 1234
VAI
PASSO 7. Executando um procedimento armazenado com um parâmetro não seletivo. O valor 50.000 é usado como parâmetro. Linhas com um valor de primeira coluna de cerca de 10.000, respectivamente, usando um índice não clusterizado e a operação de pesquisa de favoritos são ineficientes, mas como o código compilado com o plano de execução é armazenado no procedimento cache, ele será usado. O plano de execução mostra isso, bem como o fato de que uma operação de pesquisa de marcador foi executada para 9.999 linhas.
EXEC proc1 50000
VAI
PASSO 8. Realizando uma seleção de linhas com o primeiro campo igual a 50000. Quando uma consulta separada é executada, a consulta é otimizada e compilada com um valor específico da primeira coluna. Como resultado, o otimizador de consulta determina que o campo é duplicado muitas vezes e decide usar a operação de varredura de tabela, que nesse caso é muito mais eficiente do que usar um índice não clusterizado.
SELECT coluna1, coluna2 FROM sp_perf_test WHERE coluna1=50000
VAI
Assim, podemos concluir que o uso de procedimentos armazenados nem sempre pode melhorar o desempenho das consultas. Você deve ter muito cuidado com os procedimentos armazenados que trabalham com resultados com um número variável de linhas e usam planos de execução diferentes.
Você pode usar o script para repetir o experimento em seu próprio servidor MS SQL.
Tipos de procedimentos armazenados
Existem vários tipos no SQL Server procedimentos armazenados.
- Sistêmico procedimentos armazenados projetado para executar várias ações administrativas. Quase todas as ações de administração do servidor são executadas com a ajuda deles. Podemos dizer que o sistema procedimentos armazenados são uma interface que fornece trabalho com tabelas de sistema, o que, em última análise, se resume a alterar, adicionar, excluir e recuperar dados de tabelas de sistema de bancos de dados do usuário e do sistema. Sistêmico procedimentos armazenados são prefixados com sp_ , são armazenados no banco de dados do sistema e podem ser chamados no contexto de qualquer outro banco de dados.
- Personalizado procedimentos armazenados implementar determinadas ações. Procedimentos armazenados- um objeto de banco de dados completo. Como resultado disso, cada procedimento armazenado está localizado em um banco de dados específico, onde é executado.
- Temporário procedimentos armazenados existem apenas por um curto período de tempo, após o qual são automaticamente destruídos pelo servidor. Eles são divididos em locais e globais. Local temporário procedimentos armazenados só podem ser chamados a partir da conexão em que são criados. Ao criar tal procedimento, ele deve receber um nome que comece com um único caractere #. Como todos os objetos temporários, procedimentos armazenados desse tipo são excluídos automaticamente quando o usuário desconecta, reinicia ou para o servidor. Temporário global procedimentos armazenados disponível para qualquer conexão de servidor que tenha o mesmo procedimento. Para defini-lo, basta dar um nome que comece com os caracteres ## . Esses procedimentos são excluídos quando o servidor é reiniciado ou parado, ou quando a conexão em cujo contexto foram criados é fechada.
Criando, modificando e excluindo procedimentos armazenados
Criação procedimento armazenado envolve a resolução das seguintes tarefas:
- definindo o tipo de procedimento armazenado: temporário ou personalizado. Além disso, você pode criar seu próprio sistema procedimento armazenado, dando-lhe um nome com o prefixo sp_ e colocando-o no banco de dados do sistema. Tal procedimento estará disponível no contexto de qualquer banco de dados no servidor local;
- planejamento de acesso. Ao criar procedimento armazenado tenha em mente que ele terá os mesmos direitos de acesso aos objetos do banco de dados que o usuário que o criou;
- definição parâmetros de procedimento armazenado. Como os procedimentos incluídos na maioria das linguagens de programação, procedimentos armazenados pode ter parâmetros de entrada e saída;
- desenvolvimento de código procedimento armazenado. O código do procedimento pode conter uma sequência de qualquer comando SQL, incluindo a chamada de outros. procedimentos armazenados.
Criando um novo e modificando um existente procedimento armazenadoé feito com o seguinte comando:
<определение_процедуры>::= (CREATE | ALTER ) procedure_name [;number] [(@parameter_name datatype ) [=default] ][,...n] AS sql_statement [...n]
Considere os parâmetros deste comando.
Utilizando os prefixos sp_, # , ## , o procedimento criado pode ser definido como um sistema ou procedimento temporário. Como você pode ver pela sintaxe do comando, não é permitido especificar o nome do proprietário a quem o procedimento criado pertencerá, bem como o nome do banco de dados onde ele deve ser colocado. Assim, a fim de acomodar o criado procedimento armazenado em um banco de dados específico, você deve executar o comando CREATE PROCEDURE no contexto desse banco de dados. Quando manuseado a partir do corpo procedimento armazenado Nomes abreviados podem ser usados para objetos no mesmo banco de dados, ou seja, sem especificar o nome do banco de dados. Quando você deseja fazer referência a objetos localizados em outros bancos de dados, é necessário especificar o nome do banco de dados.
O número no nome é o número de identificação procedimento armazenado, que o define exclusivamente em um grupo de procedimentos. Para a conveniência de gerenciar procedimentos, logicamente o mesmo tipo procedimentos armazenados podem ser agrupados dando-lhes o mesmo nome, mas diferentes números de identificação.
Para passar dados de entrada e saída no arquivo criado procedimento armazenado parâmetros podem ser usados, cujos nomes, como os nomes das variáveis locais, devem começar com o símbolo @. Um procedimento armazenado Você pode especificar várias opções separadas por vírgulas. O corpo de um procedimento não deve usar variáveis locais cujos nomes sejam iguais aos nomes dos parâmetros do procedimento.
Para determinar o tipo de dados que o correspondente parâmetro de procedimento armazenado, qualquer tipo de dados SQL é adequado, incluindo os definidos pelo usuário. No entanto, o tipo de dados CURSOR só pode ser usado como parâmetro de saída procedimento armazenado, ou seja com a palavra-chave SAÍDA.
A presença da palavra-chave OUTPUT significa que o parâmetro correspondente destina-se a retornar dados de procedimento armazenado. No entanto, isso não significa que o parâmetro não seja adequado para passar valores para procedimento armazenado. Especificar a palavra-chave OUTPUT instrui o servidor a sair do procedimento armazenado atribua o valor atual do parâmetro à variável local que foi especificada quando o procedimento foi chamado como o valor do parâmetro. Observe que ao especificar a palavra-chave OUTPUT, o valor do parâmetro correspondente ao chamar o procedimento só pode ser definido usando uma variável local. Quaisquer expressões ou constantes permitidas para parâmetros normais não são permitidas.
A palavra-chave VARYING é usada em conjunto com
Procedimento armazenado procedimento armazenado) é um objeto de programa de banco de dados nomeado. O SQL Server tem vários tipos de procedimentos armazenados.
Procedimentos armazenados do sistema procedimento armazenado do sistema) são fornecidos por desenvolvedores de DBMS e são usados para executar ações no catálogo do sistema ou obter informações do sistema. Seus nomes geralmente começam com o prefixo "sp_". Os procedimentos armazenados de todos os tipos são executados com o comando EXECUTE, que pode ser abreviado para EXEC. Por exemplo, o procedimento armazenado sp_helplogins, executado sem parâmetros, gera dois relatórios de nomes de contas (Inglês) logins) e seus usuários correspondentes em cada banco de dados (Inglês) Comercial).
EXEC sp_helplogins;
Para dar uma ideia das ações executadas usando procedimentos armazenados do sistema, na tabela. 10.6 mostra alguns exemplos. No total, existem mais de mil procedimentos armazenados do sistema no SQL Server.
Tabela 10.6
Exemplos de procedimentos armazenados do sistema SQL Server
O usuário pode criar procedimentos armazenados em bancos de dados de usuários e no banco de dados para objetos temporários. Neste último caso, o procedimento armazenado seria temporal. Assim como nas tabelas temporárias, o nome de um procedimento armazenado temporário deve começar com um prefixo "#" se for um procedimento armazenado temporário local ou "##" se for global. Um procedimento temporário local só pode ser usado dentro da conexão em que foi criado, um global também pode ser usado em outras conexões.
Objetos programáveis do SQL Server podem ser criados usando ferramentas Transact-SQL ou usando assemblies (Inglês) assembly) no ambiente CRL (Common Language Runtime) do Microsoft .Net Framework. Neste tutorial, apenas o primeiro método será considerado.
Para criar procedimentos armazenados, use a instrução CREATE PROCEDURE (pode ser abreviada para PROC), cujo formato é fornecido abaixo:
CREATE (PROC I PROCEDURE) proc_name [ ; número]
[(gparameter data_type )
[“padrão] |
[COM
[ PARA REPLICAÇÃO ]
AS ([ BEGIN ] sql_statement [;] [ ...n ] [ END ] )
Se um procedimento armazenado (ou gatilho, função, exibição) for criado com a opção ENCRYPTION, seu código será convertido de forma que o texto se torne ilegível. Ao mesmo tempo, conforme observado em , o algoritmo usado é transportado de versões anteriores do SQL Server e não pode ser considerado um algoritmo de proteção confiável - existem utilitários que permitem executar rapidamente a conversão reversa.
A opção RECOMPILE especifica que cada vez que o procedimento for chamado, o sistema recompilará o texto. No caso usual, o procedimento compilado na primeira execução é armazenado no cache, o que permite aumentar o desempenho.
EXECUTE AS define o contexto de segurança no qual o procedimento deve ser executado. A seguir, um dos valores f CALLER | AUTO | PROPRIETÁRIO | "nome do usuário"). CALLER é o valor padrão e significa que o código será executado no contexto de segurança do usuário que está chamando este módulo. Assim, o usuário deve ter permissões não apenas para o próprio objeto programável, mas também para outros objetos de banco de dados afetados por ele. EXECUTE AS SELF significa usar o contexto de um usuário criando ou modificando um objeto programável. OWNER especifica que o código será executado no contexto do proprietário atual do procedimento. Se nenhum proprietário for definido para ele, será assumido o proprietário do esquema ao qual ele pertence. EXECUTE AS "user_name" permite especificar explicitamente o nome de usuário (entre aspas simples).
Os parâmetros podem ser especificados para um procedimento. São variáveis locais usadas para passar valores para um procedimento. Se um parâmetro for declarado com a palavra-chave OUTPUT (ou OUT para abreviar), é uma saída: o valor dado a ele no procedimento pode ser usado pelo programa que chamou o procedimento após o término. A palavra-chave READONLY significa que o valor do parâmetro não pode ser alterado dentro do procedimento armazenado.
Os parâmetros podem receber valores padrão, que serão usados se o valor do parâmetro não for especificado explicitamente ao chamar o procedimento. Considere um exemplo:
CREATE PROC surma (@a int, @b int=0,
©resultado int SAÍDA) AS
SET @resultado=0a+0b
Criamos um procedimento com três parâmetros, onde o parâmetro @b tem o valor padrão de 0, e o parâmetro @result é um parâmetro de saída: através dele, o valor é retornado ao programa chamador. As ações realizadas são bastante simples - o parâmetro de saída recebe o valor da soma das duas entradas.
Ao trabalhar no SQL Server Management Studio, o procedimento armazenado criado pode ser encontrado na seção de objetos de banco de dados programáveis (Inglês) Programabilidade) na seção de procedimentos armazenados (Figura 10.2).
Ao chamar um procedimento, variáveis e constantes podem ser usadas como parâmetros de entrada. Vamos considerar dois exemplos. Na primeira, os parâmetros de entrada do procedimento são definidos explicitamente por constantes, a palavra-chave OUTPUT é especificada para o parâmetro de saída na chamada. Na segunda opção, o valor da variável é usado como o primeiro parâmetro de entrada, e o segundo parâmetro é especificado usando a palavra-chave DEFAULT que o valor padrão deve ser usado:
Arroz. 10.2.
DECLARE @com int;
EXEC soma 10,5,@c OUTPUT;
IMPRIMIR0c; - 15 será exibido
DECLARE Giint = 5;
- ao chamar, use o valor padrão
EXEC soma Gi,DEFAULT , 0s OUTPUT;
IMPRIMIR0c; - 5 será exibido
Considere agora um exemplo com a análise do código de retorno com o qual o procedimento termina. Que seja necessário calcular quantos livros da tabela Bookl foram publicados em um determinado intervalo de anos. Neste caso, se o ano inicial for maior que o ano final, o procedimento retorna "1" e não conta, caso contrário, contamos o número de livros e retornamos 0:
CREATE PROC dbo.rownum(0FirsYear int, GLastYear int, 0result int OUTPUT) AS
SE 0Primeiro Ano>0Último Ano RETORNO 1
SET @result= (SELECT COUNT(*) FROM dbo.Bookl
ONDE ENTRE 0Primeiro Ano E 0Último Ano);
Considere uma variante de chamada deste procedimento, na qual o código de retorno é armazenado na variável inteira 0ret, após o que seu valor é analisado (neste caso será 1). A função CAST usada na instrução PRINT é usada para converter o valor de uma variável inteira Gres em um tipo de string:
DECLARE 0ret int, Gres int
EXEC Gret = rownum 2004, 2002, Gres OUT;
IF 0ret=l PRINT "O ano inicial é maior que o ano final"
PRINT "Número de livros" + CAST(Gres as varchar(20))
Os procedimentos armazenados podem não apenas ler dados de uma tabela, mas também modificar dados e até criar tabelas e vários outros objetos de banco de dados.
No entanto, esquemas, funções, gatilhos, procedimentos e exibições não podem ser criados a partir de um procedimento armazenado.
O exemplo a seguir ilustra essas possibilidades e problemas relacionados ao escopo de objetos temporários. O procedimento armazenado a seguir verifica a existência de uma tabela temporária #Tab2; se esta tabela não existir, ele a cria. Depois disso, os valores de duas colunas são inseridos na tabela #Tab2, e o conteúdo da tabela é exibido pela instrução SELECT:
CREATE PROC My_Procl (@id int, @name varchar(30))
IF OBJECT_ID("tempdb.dbo.#Tab21) É NULO
INSERT INTO dbo.#Tab2 (id, name)VALUES (0id,0name)
SELECIONE * DE dbo. #Tab2 -#1
Antes da primeira chamada para o procedimento armazenado, vamos criar a tabela temporária #Tab2 usada nele. Preste atenção ao operador EXEC. Nos exemplos anteriores, os parâmetros foram passados para o procedimento "por posição", mas neste caso, um formato diferente para passar parâmetros é usado - "por nome", o nome do parâmetro e seu valor são indicados explicitamente:
CREATE TABLE dbo.#Tab2 (id int, nome varchar(30));
EXEC Meu_Procl 0name="lvan", 0id=2;
SELECT * FROM dbo.#Tab2; –#2
No exemplo acima, a instrução SELECT será executada duas vezes: a primeira vez - dentro do procedimento, a segunda vez - a partir do fragmento de código de chamada (marcado com o comentário "Nº 2").
Antes da segunda chamada de procedimento, vamos deletar a tabela temporária #Tab2. Em seguida, a tabela temporária de mesmo nome será criada a partir do procedimento armazenado:
DROP TABLE dbo.#Tab2;
EXEC Meu_Procl 0name="Ivan", 0id=2;
SELECT * FROM dbo.#Tab2; –#2
Nesse caso, apenas a instrução SELECT dentro do procedimento (com o comentário "Xa 1") exibirá os dados. A execução de SELECT "#2" resultará em erro, pois a tabela temporária criada no procedimento armazenado já será excluída do banco de dados tempdb quando o procedimento retornar.
Você pode descartar um procedimento armazenado usando a instrução DROP PROCEDURE. Seu formato é mostrado abaixo. Com uma instrução, você pode excluir vários procedimentos armazenados listando-os separados por vírgulas:
DROP (PROC I PROCEDIMENTO) (procedimento) [
Por exemplo, vamos remover o procedimento summa criado anteriormente:
DROP PROC summa;
Você pode fazer alterações em um procedimento existente (na verdade, substituí-lo) usando a instrução ALTER PROCEDURE (permitir
abreviatura PROC). Com exceção da palavra-chave ALTER, o formato da instrução é quase o mesmo de CREATE PROCEDURE. Por exemplo, vamos alterar o procedimento dbo. rownum configurando-o para executar no contexto de segurança do proprietário:
ALTER PROC dbo.rownum(SFirsYear int,
SLastYear int, Sresult int OUTPUT)
COM EXECUTAR COMO Proprietário - definir opção
SE 0Primeiro Ano>0Último Ano RETURN 1 ELSE BEGIN
SET 0result= (SELECT COUNT(*) FROM dbo.Bookl
ONDE ENTRE SFirsYear E SLastYear);
Em alguns casos, pode ser necessário gerar um comando dinamicamente e executá-lo no servidor de banco de dados. Esta tarefa também pode ser resolvida usando o operador EXEC. O exemplo a seguir seleciona registros da tabela Bookl com base na condição de que o atributo Year seja igual ao valor especificado pela variável:
DECLARE 0y int = 2000;
EXEC("SELECT * FROM dbo.Bookl WHERE = " [e-mail protegido]) ;
A execução de instruções geradas dinamicamente cria os pré-requisitos para a implementação de ataques de computador, como "injeção de SQL" (Inglês) Injeção SQL). A essência do ataque é que o infrator injeta seu próprio código SQL em uma consulta gerada dinamicamente. Isso geralmente acontece quando os parâmetros embutidos são obtidos dos resultados de entrada do usuário.
Vamos mudar um pouco o exemplo anterior:
DECLARE 0y varchar(100);
SET 0y="2OOO"; - isto é o que recebemos do usuário
Se presumirmos que recebemos o valor da string atribuído na instrução SET do usuário (não importa como, por exemplo, por meio de um aplicativo da Web), o exemplo ilustra o comportamento "regular" do nosso código.
DECLARE 0y varchar(100);
SET 0y="2000; DELETE DE dbo.Book2"; – injeção
EXEC("SELECT * FROM dbo.Book2 WHERE="+0y);
Recomenda-se, sempre que possível, a utilização do procedimento armazenado do sistema sp_executcsql nesses casos, que permite controlar o tipo de parâmetros, que é uma das barreiras à injeção de SQL. Sem considerar detalhadamente seu formato, analisaremos um exemplo semelhante ao apresentado anteriormente:
EXECUTAR sp_executesql
N"SELECT * FROM dbo.Bookl WHERE =0y",
Isso especifica explicitamente o tipo de parâmetro usado na consulta e o SQL Server o controlará durante a execução. A letra "N" antes das aspas indica que esta é uma constante literal Unicode, conforme exigido pelo procedimento. A um parâmetro pode ser atribuído não apenas um valor constante, mas também o valor de outra variável.
Procedimento armazenadoé um tipo especial de lote de instruções Transact-SQL criado usando a linguagem SQL e extensões procedurais. A principal diferença entre um pacote e um procedimento armazenado é que o último é armazenado como um objeto de banco de dados. Em outras palavras, os procedimentos armazenados são armazenados no lado do servidor para melhorar o desempenho e a consistência de tarefas repetitivas.
O Mecanismo de Banco de Dados oferece suporte a procedimentos armazenados e procedimentos do sistema. Os procedimentos armazenados são criados da mesma forma que todos os outros objetos de banco de dados, ou seja, usando a linguagem DDL. Procedimentos do sistema são fornecidos pelo Mecanismo de Banco de Dados e podem ser usados para acessar e modificar informações no catálogo do sistema.
Ao criar um procedimento armazenado, você pode definir uma lista opcional de parâmetros. Assim, o procedimento receberá os argumentos apropriados cada vez que for chamado. Os procedimentos armazenados podem retornar um valor contendo informações definidas pelo usuário ou, no caso de um erro, uma mensagem de erro apropriada.
Um procedimento armazenado é pré-compilado antes de ser armazenado como um objeto no banco de dados. A forma pré-compilada do procedimento é armazenada no banco de dados e usada sempre que é chamada. Essa propriedade de procedimentos armazenados fornece o importante benefício de eliminar (em quase todos os casos) recompilações de procedimentos e obter uma melhoria de desempenho correspondente. Essa propriedade dos procedimentos armazenados também tem um efeito positivo na quantidade de dados trocados entre o sistema de banco de dados e os aplicativos. Em particular, uma chamada para um procedimento armazenado de vários milhares de bytes pode exigir menos de 50 bytes. Quando vários usuários executam tarefas repetitivas usando procedimentos armazenados, o efeito cumulativo dessas economias pode ser significativo.
Os procedimentos armazenados também podem ser usados para os seguintes propósitos:
para criar um log de logs sobre ações com tabelas de banco de dados.
O uso de procedimentos armazenados fornece um nível de controle de segurança que vai muito além da segurança oferecida pelo uso de instruções GRANT e REVOKE, que concedem diferentes privilégios de acesso aos usuários. Isso é possível porque a autorização para executar um procedimento armazenado é independente da autorização para modificar os objetos contidos no procedimento armazenado, conforme descrito na próxima seção.
Os procedimentos armazenados que registram gravações e/ou leituras em tabelas fornecem segurança adicional para o banco de dados. Usando esses procedimentos, o administrador do banco de dados pode acompanhar as modificações feitas no banco de dados por usuários ou aplicativos.
Criando e executando procedimentos armazenados
Os procedimentos armazenados são criados usando a instrução CRIAR PROCEDIMENTO, que tem a seguinte sintaxe:
CREATE PROC proc_name [((@param1) type1 [ VARYING] [= default1] )] (, …) AS batch | EXTERNAL NAME method_name Convenções de sintaxe
O parâmetro schema_name especifica o nome do esquema atribuído pelo proprietário do procedimento armazenado gerado. O parâmetro proc_name especifica o nome do procedimento armazenado. O parâmetro @param1 é um parâmetro de procedimento (um argumento formal) cujo tipo de dados é especificado pelo parâmetro type1. Os parâmetros de procedimento são locais dentro de um procedimento, assim como as variáveis locais são locais dentro de um pacote. Parâmetros de procedimento são valores que são passados pelo chamador ao procedimento para uso nele. O parâmetro default1 especifica o valor padrão para o parâmetro de procedimento correspondente. (O valor padrão também pode ser NULL.)
Opção de SAÍDA especifica que um parâmetro de procedimento é retornável e pode ser usado para retornar um valor de um procedimento armazenado para o procedimento ou sistema de chamada.
Conforme mencionado anteriormente, a forma pré-compilada do procedimento é armazenada no banco de dados e usada sempre que é chamada. Se, por algum motivo, um procedimento armazenado precisar ser compilado toda vez que for chamado, a declaração do procedimento usará opção COM RECOMPILAR. Usar a opção WITH RECOMPILE anula um dos benefícios mais importantes dos procedimentos armazenados: a melhoria de desempenho devido a uma única compilação. Portanto, a opção WITH RECOMPILE só deve ser usada se houver alterações frequentes nos objetos de banco de dados usados pelo procedimento armazenado.
EXECUTAR COMO oferta define o contexto de segurança no qual o procedimento armazenado deve ser executado após ser chamado. Ao definir esse contexto, o Mecanismo de Banco de Dados pode controlar a seleção de contas de usuário para verificar as permissões de acesso em objetos referenciados por esse procedimento armazenado.
Por padrão, somente os membros da função de servidor fixa sysadmin e a função de banco de dados fixa db_owner ou db_ddladmin podem usar a instrução CREATE PROCEDURE. No entanto, os membros dessas funções podem atribuir esse direito a outros usuários usando a instrução PROCEDIMENTO DE CRIAÇÃO DE CONCESSÃO.
O exemplo abaixo mostra como criar um procedimento armazenado simples para trabalhar com a tabela Project:
USE SampleDB; GO CREATE PROCEDURE IncreaseBudget (@percent INT=5) AS UPDATE Projeto SET Orçamento = Orçamento + Orçamento * @percent/100;
Como mencionado anteriormente, para separar dois pacotes é usado instrução GO. A instrução CREATE PROCEDURE não pode ser combinada com outras instruções Transact-SQL no mesmo lote. O procedimento armazenado IncreaseBudget aumenta os orçamentos de todos os projetos em uma determinada porcentagem, especificada pelo parâmetro @percent. O procedimento também define um valor percentual padrão (5) que é aplicado se este argumento não estiver presente durante a execução do procedimento.
Os procedimentos armazenados podem acessar tabelas que não existem. Essa propriedade permite que você depure o código do procedimento sem primeiro criar as tabelas apropriadas e nem mesmo se conectar ao servidor de destino.
Ao contrário dos procedimentos armazenados básicos, que sempre são armazenados no banco de dados atual, é possível criar procedimentos armazenados temporários, que são sempre colocados no banco de dados temporário do sistema tempdb. Uma das razões para criar procedimentos armazenados temporários pode ser evitar a execução repetitiva de um determinado grupo de instruções ao conectar-se a um banco de dados. Você pode criar procedimentos temporários locais ou globais. Para fazer isso, o nome do procedimento local é especificado com um único caractere # (#proc_name) e o nome do procedimento global é especificado com um caractere duplo (##proc_name).
Um procedimento armazenado temporário local só pode ser executado pelo usuário que o criou e somente durante a conexão com o banco de dados no qual foi criado. Um procedimento temporário global pode ser executado por todos os usuários, mas somente até que a última conexão na qual ele está sendo executado (geralmente a conexão do criador do procedimento) seja encerrada.
O ciclo de vida de um procedimento armazenado consiste em duas fases: sua criação e sua execução. Cada procedimento é criado uma vez e executado várias vezes. O procedimento armazenado é executado por EXECUTAR declarações um usuário que possui o procedimento ou tem o direito EXECUTE para acessar o procedimento. A instrução EXECUTE tem a seguinte sintaxe:
[] [@return_status =] (proc_name | @proc_name_var) ([[@parameter1 =] valor | [@parameter1=] @variable ] | DEFAULT).. Convenções de sintaxe
Com exceção do parâmetro return_status, todos os parâmetros da instrução EXECUTE têm o mesmo valor booleano que os parâmetros da instrução CREATE PROCEDURE de mesmo nome. O parâmetro return_status define uma variável inteira que armazena o status de retorno do procedimento. Um valor pode ser atribuído a um parâmetro usando uma constante (valor) ou uma variável local (@variável). A ordem dos valores de parâmetros nomeados não é importante, mas os valores de parâmetros não nomeados devem ser fornecidos na ordem em que são definidos na instrução CREATE PROCEDURE.
Cláusula DEFAULT fornece valores padrão para um parâmetro de procedimento que foi especificado na definição do procedimento. Quando um procedimento espera um valor para um parâmetro para o qual nenhum valor padrão foi definido e o parâmetro está ausente ou a palavra-chave DEFAULT é especificada, ocorre um erro.
Quando a instrução EXECUTE é a primeira instrução em um lote, a palavra-chave EXECUTE pode ser omitida. No entanto, é mais seguro incluir esta palavra em todos os pacotes. O uso da instrução EXECUTE é mostrado no exemplo abaixo:
USE SampleDB; EXECUTAR AumentarOrçamento 10;
A instrução EXECUTE neste exemplo executa o procedimento armazenado IncreaseBudget, que aumenta o orçamento de todos os projetos em 10%.
O exemplo a seguir mostra como criar um procedimento armazenado para processar dados nas tabelas Employee e Works_on:
O procedimento ModifyEmpId no exemplo ilustra o uso de procedimentos armazenados como parte do processo de integridade referencial (neste caso, entre as tabelas Employee e Works_on). Esse procedimento armazenado pode ser usado dentro de uma definição de gatilho, que na verdade impõe a integridade referencial.
O exemplo a seguir mostra o uso da cláusula OUTPUT em um procedimento armazenado:
Este procedimento armazenado pode ser executado usando as seguintes instruções:
DECLARE @quantityDeleteEmployee INT; EXECUTAR ExcluirFuncionário @empId=18316, @ [e-mail protegido] SAÍDA; PRINT N"Funcionários excluídos: " + convert(nvarchar(30), @quantityDeleteEmployee);
Este procedimento conta o número de projetos em que um funcionário com número pessoal @empId está trabalhando e atribui o valor resultante ao parâmetro ©counter. Após excluir todas as linhas de um determinado número pessoal das tabelas Employee e Works_on, o valor calculado é atribuído à variável @quantityDeleteEmployee.
O valor do parâmetro é retornado ao procedimento de chamada somente se a opção OUTPUT for especificada. No exemplo acima, o procedimento DeleteEmployee passa o parâmetro @counter para o procedimento de chamada, para que o procedimento armazenado retorne o valor ao sistema. Portanto, o parâmetro @counter deve ser especificado tanto na opção OUTPUT ao declarar o procedimento, quanto na instrução EXECUTE ao chamá-lo.
cláusula WITH RESULTS SETS de uma instrução EXECUTE
No SQL Server 2012, a instrução EXECUTE é digitada cláusula WITH RESULTS SETS Um que, sob certas condições, pode alterar a forma do conjunto de resultados do procedimento armazenado.
Os dois exemplos a seguir ajudarão a explicar essa frase. O primeiro exemplo é um exemplo introdutório que mostra como o resultado pode ficar quando a cláusula WITH RESULTS SETS é omitida:
O procedimento EmployeesInDept é um procedimento simples que exibe os números pessoais e os sobrenomes de todos os funcionários que trabalham em um departamento específico. O número do departamento é um parâmetro de procedimento e deve ser especificado ao chamar o procedimento. A execução deste procedimento gera uma tabela com duas colunas cujos títulos correspondem aos nomes das colunas correspondentes na tabela do banco de dados, ou seja, id e sobrenome. Para alterar os cabeçalhos das colunas de resultados (assim como seu tipo de dados), o SQL Server 2012 usa a nova cláusula WITH RESULTS SETS. A aplicação desta cláusula é mostrada no exemplo abaixo:
USE SampleDB; EXEC EmployeesInDept "d1" COM CONJUNTOS DE RESULTADOS (( INT NOT NULL, [Last Name] CHAR(20) NOT NULL));
O resultado da execução de um procedimento armazenado chamado dessa maneira será o seguinte:
Como você pode ver, a execução de um procedimento armazenado usando a cláusula WITH RESULT SETS em uma instrução EXECUTE permite alterar os nomes e o tipo de dados das colunas do conjunto de resultados produzidas pelo procedimento. Assim, essa nova funcionalidade oferece mais flexibilidade na execução de procedimentos armazenados e na colocação de seus resultados em uma nova tabela.
Alterando a Estrutura de Procedimentos Armazenados
O Mecanismo de Banco de Dados também suporta a instrução ALTERAR PROCEDIMENTO para modificar a estrutura de procedimentos armazenados. A instrução ALTER PROCEDURE normalmente é usada para modificar instruções Transact-SQL em um procedimento. Todos os parâmetros da instrução ALTER PROCEDURE têm o mesmo significado que os parâmetros da instrução CREATE PROCEDURE de mesmo nome. O objetivo principal de usar essa instrução é evitar substituir as permissões de procedimento armazenado existentes.
O Mecanismo de Banco de Dados suporta Tipo de dados CURSOR. Esse tipo de dados é usado para declarar cursores em procedimentos armazenados. Cursoré uma construção de programação usada para armazenar os resultados de uma consulta (geralmente um conjunto de linhas) e para permitir que os usuários exibam esse resultado linha por linha.
Para remover um ou um grupo de procedimentos armazenados, use Declaração DROP PROCEDURE. Somente o proprietário do procedimento armazenado ou os membros das funções fixas db_owner e sysadmin podem excluir um procedimento armazenado.
Procedimentos armazenados e o Common Language Runtime
O SQL Server oferece suporte ao Common Language Runtime (CLR), que permite desenvolver vários objetos de banco de dados (procedimentos armazenados, funções definidas pelo usuário, gatilhos, agregados definidos pelo usuário e tipos de dados definidos pelo usuário) usando C# e Visual Basic. O Common Language Runtime também permite que esses objetos sejam executados usando o Common Runtime System.
O Common Language Runtime é habilitado e desabilitado por meio da opção clr_enabled procedimento do sistema sp_configure, que é lançado para execução pela instrução RECONFIGURAR. O exemplo a seguir mostra como você pode habilitar o Common Language Runtime usando o procedimento do sistema sp_configure:
USE SampleDB; EXEC sp_configure "clr_enabled",1 RECONFIGURE
Criar, compilar e salvar um procedimento usando o CLR requer a seguinte sequência de etapas, na ordem listada:
Crie um procedimento armazenado em C# ou Visual Basic e compile-o usando o compilador apropriado.
Usando instruções CRIAR MONTAGEM, crie o executável apropriado.
Execute um procedimento usando a instrução EXECUTE.
A figura abaixo mostra um diagrama gráfico das etapas descritas anteriormente. A seguir, uma descrição mais detalhada desse processo.
Primeiro, crie o programa desejado em um ambiente de desenvolvimento como o Visual Studio. Compile o programa finalizado para código de objeto usando o compilador C# ou Visual Basic. Esse código é armazenado em um arquivo de biblioteca de vínculo dinâmico (.dll) que serve como fonte para a instrução CREATE ASSEMBLY, que cria um código executável intermediário. Em seguida, emita uma instrução CREATE PROCEDURE para salvar o código que está sendo executado como um objeto de banco de dados. Finalmente, execute o procedimento usando a instrução EXECUTE familiar.
O exemplo abaixo mostra o código-fonte do procedimento armazenado em C#:
Usando System.Data.SqlClient; usando Microsoft.SqlServer.Server; public parcial classe StoredProcedures ( public static int CountEmployees() ( int rows; SqlConnection connection = new SqlConnection("Context Connection=true"); connection.Open(); SqlCommand cmd = connection.CreateCommand(); cmd.CommandText = "select count(*) as "Número de funcionários" " + "de Funcionário"; rows = (int)cmd.ExecuteScalar(); connection.Close(); return rows; ) )
Este procedimento implementa uma consulta para contar o número de linhas na tabela Employee. O uso de diretivas no início de um programa especifica os namespaces necessários para sua execução. O uso dessas diretivas permite especificar nomes de classes no código-fonte sem especificar explicitamente os namespaces correspondentes. Em seguida, é definida a classe StoredProcedures, para a qual o Atributo SqlProcedure, que informa ao compilador que essa classe é um procedimento armazenado. Dentro do código da classe, o método CountEmployees() é definido. A conexão com o sistema de banco de dados é estabelecida através de uma instância da classe SqlConnection. Para abrir uma conexão, é utilizado o método Open() desta instância. UMA Método CreateCommand() permite acessar uma instância de uma classe SqlCommnd, para o qual o comando SQL desejado é passado.
No trecho de código a seguir:
Cmd.CommandText = "selecione count(*) como "Número de funcionários" " + "do Funcionário";
usa uma instrução SELECT para contar o número de linhas na tabela Employee e exibir o resultado. O texto do comando é especificado definindo a propriedade CommandText da variável cmd para a instância retornada pelo método CreateCommand(). O próximo é chamado Método ExecuteScalar() instância do SqlCommand. Esse método retorna um valor escalar que é convertido no tipo de dados inteiro int e atribuído à variável rows.
Agora você pode compilar esse código usando o Visual Studio. Eu adicionei esta classe ao projeto com o nome CLRStoredProcedures, então o Visual Studio irá compilar o assembly de mesmo nome com a extensão *.dll. O exemplo abaixo mostra a próxima etapa na criação de um procedimento armazenado: criar o código a ser executado. Antes de executar o código neste exemplo, você precisa saber a localização do arquivo .dll compilado (geralmente localizado na pasta Debug do projeto).
USE SampleDB; GO CREATE ASSEMBLY CLRStoredProcedures FROM "D:\Projects\CLRStoredProcedures\bin\Debug\CLRStoredProcedures.dll" COM PERMISSION_SET = SAFE
A instrução CREATE ASSEMBLY usa o código gerenciado como entrada e cria um objeto apropriado para o qual você pode criar procedimentos armazenados do Common Language Runtime (CLR), funções definidas pelo usuário e gatilhos. Esta instrução tem a seguinte sintaxe:
CREATE ASSEMBLY assembly_name [ AUTHORIZATION owner_name ] FROM (dll_file) Convenções de sintaxe
O parâmetro assembly_name especifica o nome do assembly. A cláusula opcional AUTHORIZATION especifica o nome de uma função como o proprietário deste assembly. A cláusula FROM especifica o caminho onde o assembly a ser carregado está localizado.
Cláusula WITH PERMISSION_SETé uma cláusula muito importante da instrução CREATE ASSEMBLY e deve sempre ser especificada. Ele define o conjunto de direitos de acesso concedidos ao código assembly. O conjunto de direitos SAFE é o mais restritivo. O código assembly que possui esses direitos não pode acessar recursos externos do sistema, como arquivos. O conjunto de direitos EXTERNAL_ACCESS permite que o código assembly acesse determinados recursos externos do sistema, enquanto o conjunto de direitos UNSAFE fornece acesso irrestrito aos recursos, tanto dentro quanto fora do sistema de banco de dados.
Para armazenar informações de código de montagem, o usuário deve poder emitir uma instrução CREATE ASSEMBLY. O assembly é de propriedade do usuário (ou função) que executa a instrução. Você pode alterar o proprietário de um assembly usando a cláusula AUTHORIZATION da instrução CREATE SCHEMA.
O Mecanismo de Banco de Dados também oferece suporte às instruções ALTER ASSEMBLY e DROP ASSEMBLY. Declaração ALTER ASSEMBLY usado para atualizar um assembly para a versão mais recente. Esta instrução também adiciona ou remove arquivos associados ao assembly correspondente. Declaração de SOLTAR CONJUNTO remove o assembly especificado e todos os arquivos associados do banco de dados atual.
O exemplo a seguir mostra como criar um procedimento armazenado com base no código gerenciado implementado anteriormente:
USE SampleDB; GO CREATE PROCEDURE CountEmployees AS EXTERNAL NAME CLRStoredProcedures.StoredProcedures.CountEmployees
A instrução CREATE PROCEDURE no exemplo difere da mesma instrução nos exemplos anteriores, pois contém Parâmetro EXTERNAL NAME. Esta opção especifica que o código é gerado pelo CLR. O nome nesta frase consiste em três partes:
assembly_name.class_name.method_name
assembly_name - especifica o nome do assembly;
class_name - especifica o nome da classe geral;
method_name - parte opcional, especifica o nome do método definido dentro da classe.
A execução do procedimento CountEmployees é mostrada no exemplo abaixo:
USE SampleDB; DECLARE @count INT EXECUTE @count = CountEmployees PRINT @count -- Retorna 7
A instrução PRINT retorna o número atual de linhas na tabela Employee.
No Microsoft SQL Server para implementar e automatizar seus próprios algoritmos ( cálculos) você pode usar procedimentos armazenados, então hoje falaremos sobre como eles são criados, modificados e excluídos.
Mas antes, um pouco de teoria para que você entenda o que são stored procedures e para que servem no T-SQL.
Observação! Para programadores iniciantes, recomendo os seguintes materiais úteis sobre o tópico T-SQL:
- Para um estudo mais detalhado da linguagem T-SQL, recomendo também a leitura do livro - The Way of the T-SQL Programmer. Tutorial Transact-SQL.
O que são procedimentos armazenados no T-SQL?
Procedimentos armazenados- São objetos de banco de dados nos quais o algoritmo está embutido na forma de um conjunto de instruções SQL. Em outras palavras, podemos dizer que stored procedures são programas dentro de um banco de dados. Os procedimentos armazenados são usados para armazenar código reutilizável no servidor, por exemplo, você escreveu um algoritmo, um cálculo sequencial ou uma instrução SQL de várias etapas e, para não executar todas as instruções incluídas neste algoritmo a cada vez, você pode organizar como um procedimento armazenado. Nesse caso, quando você cria um procedimento SQL, o servidor compila o código e, em seguida, cada vez que você executa esse procedimento, o servidor SQL não o compilará mais novamente.
Para executar um procedimento armazenado no SQL Server, é necessário escrever o comando EXECUTE antes de seu nome, também é possível escrever este comando EXEC de forma abreviada. Chame um procedimento armazenado em uma instrução SELECT, por exemplo, pois uma função não funcionará mais, ou seja, procedimentos são executados separadamente.
Nos procedimentos armazenados, diferentemente das funções, já é possível realizar operações de modificação de dados como: UNSERT, UPDATE, DELETE. Além disso, em procedimentos, você pode usar quase qualquer tipo de instrução SQL, por exemplo, CREATE TABLE para criar tabelas ou EXECUTE, ou seja, chamando outros procedimentos. A exceção são vários tipos de instruções como: criar ou alterar funções, visualizações, triggers, criar esquemas e algumas outras instruções semelhantes, por exemplo, também é impossível alternar o contexto de conexão do banco de dados (USE) em um procedimento armazenado.
Um procedimento armazenado pode ter parâmetros de entrada e parâmetros de saída, pode retornar dados tabulares, pode não retornar nada, mas apenas executar as instruções contidas nele.
Os procedimentos armazenados são muito úteis, eles nos ajudam a automatizar ou simplificar muitas operações, por exemplo, você precisa constantemente gerar vários relatórios analíticos complexos usando tabelas dinâmicas, ou seja, Operador PIVOT. Para simplificar a formação de consultas com este operador ( como você sabe, a sintaxe PIVOT é bastante complicada), você pode escrever um procedimento que gerará relatórios resumidos dinamicamente para você, por exemplo, no material “PIVOT Dinâmico em T-SQL”, é apresentado um exemplo de implementação desse recurso na forma de um procedimento armazenado.
Exemplos de trabalho com procedimentos armazenados no Microsoft SQL Server
Dados iniciais para exemplos
Todos os exemplos abaixo serão executados no Microsoft SQL Server 2016 Express. Para demonstrar como os procedimentos armazenados funcionam com dados reais, precisamos desses dados, vamos criá-los. Por exemplo, vamos criar uma tabela de teste e adicionar alguns registros a ela, digamos que será uma tabela contendo uma lista de produtos com seus preços.
Instrução de criação de tabela CREATE TABLE TestTable( INT IDENTITY(1,1) NOT NULL, INT NOT NULL, VARCHAR(100) NOT NULL, MONEY NULL) GO -- Adicionar instrução de dados INSERT INTO TestTable(CategoryId, ProductName, Price) VALUES (1 , "Mouse", 100), (1, "Teclado", 200), (2, "Telefone", 400) GO -- SELECT * FROM TestTable query
Existem dados, agora vamos passar para a criação de procedimentos armazenados.
Criando um procedimento armazenado em T-SQL - instrução CREATE PROCEDURE
Os procedimentos armazenados são criados usando a instrução CRIAR PROCEDIMENTO, após esta instrução você deve escrever o nome do seu procedimento, então, se necessário, defina os parâmetros de entrada e saída entre colchetes. Depois disso, você escreve a palavra-chave AS e abre um bloco de instruções com a palavra-chave BEGIN, fecha este bloco com a palavra END. Dentro deste bloco, você escreve todas as instruções que implementam seu algoritmo ou algum tipo de cálculo sequencial, ou seja, você programa em T-SQL.
Por exemplo, vamos escrever um procedimento armazenado que adicionará um novo registro, ou seja, novo item para o nosso gráfico de teste. Para isso, definiremos três parâmetros de entrada: @CategoryId - identificador da categoria do produto, @ProductName - nome do produto e @Price - preço do produto, este parâmetro será opcional para nós, ou seja, não pode ser passado para o procedimento ( por exemplo, ainda não sabemos o preço), para isso definiremos o valor padrão em sua definição. Esses parâmetros estão no corpo do procedimento, ou seja, no bloco BEGIN…END podem ser usados da mesma forma que as variáveis comuns ( como você sabe, as variáveis são indicadas pelo sinal @). Se você precisar especificar parâmetros de saída, depois do nome do parâmetro, especifique a palavra-chave OUTPUT ( ou abreviado OUT).
No bloco BEGIN…END, escreveremos uma instrução para adicionar dados, e também ao final do procedimento, uma instrução SELECT para que o procedimento armazenado retorne dados tabulares sobre os produtos da categoria especificada, levando em consideração o novo, acabou de adicionar produto. Também neste procedimento armazenado, adicionei o processamento do parâmetro de entrada, ou seja, a remoção de espaços extras no início e no final da string de texto para evitar situações em que vários espaços foram inseridos acidentalmente.
Aqui está o código para este procedimento Eu também comentei sobre isso).
Criar procedimento CREATE PROCEDURE TestProcedure (--Parâmetros de entrada @CategoryId INT, @ProductName VARCHAR(100), @Price MONEY = 0) AS BEGIN --Instruções que implementam seu algoritmo --Processando parâmetros de entrada --Removendo espaços extras no início e no final da string de texto SET @ProductName = LTRIM(RTRIM(@ProductName)); --Adicionar nova entrada INSERT INTO TestTable(CategoryId, ProductName, Price) VALUES (@CategoryId, @ProductName, @Price) --Return data SELECT * FROM TestTable WHERE CategoryId = @CategoryId END GO
Executando um procedimento armazenado em T-SQL - Comando EXECUTE
Você pode executar um procedimento armazenado, como já observei, usando o comando EXECUTE ou EXEC. Os parâmetros de entrada são passados para os procedimentos simplesmente enumerando-os e fornecendo os valores apropriados após o nome do procedimento ( para parâmetros de saída, você também deve especificar o comando OUTPUT). No entanto, o nome dos parâmetros pode não ser especificado, mas neste caso é necessário seguir a sequência de especificação dos valores, ou seja, especifique os valores na ordem em que os parâmetros de entrada são definidos ( isso também se aplica aos parâmetros de saída).
Os parâmetros que possuem valores padrão podem não ser especificados, são os chamados parâmetros opcionais.
Aqui estão algumas maneiras diferentes, mas equivalentes, de executar procedimentos armazenados, especificamente nosso procedimento de teste.
1. Chame o procedimento sem especificar o preço EXECUTE TestProcedure @CategoryId = 1, @ProductName = "Test product 1" --2. Chamamos o procedimento com o preço especificado EXEC TestProcedure @CategoryId = 1, @ProductName = "Test product 2", @Price = 300 --3. Chamamos o procedimento sem especificar o nome dos parâmetros EXEC TestProcedure 1, "Test item 3", 400
Alterando um procedimento armazenado para T-SQL - instrução ALTER PROCEDURE
Você pode fazer alterações no algoritmo do procedimento usando as instruções ALTERAR PROCEDIMENTO. Em outras palavras, para alterar um procedimento já existente, você só precisa escrever ALTER PROCEDURE em vez de CREATE PROCEDURE e alterar todo o resto conforme necessário.
Digamos que precisamos fazer alterações em nosso procedimento de teste, digamos, o parâmetro @Price, ou seja, price, vamos torná-lo obrigatório, para isso vamos remover o valor padrão, e também imaginar que não precisamos mais obter o conjunto de dados resultante, para isso simplesmente removeremos a instrução SELECT do procedimento armazenado.
Altere o procedimento ALTER PROCEDURE TestProcedure (--Incoming parameters @CategoryId INT, @ProductName VARCHAR(100), @Price MONEY) AS BEGIN --Instruções que implementam seu algoritmo --Processando parâmetros de entrada --Remove espaços extras no início e no final das linhas de texto SET @ProductName = LTRIM(RTRIM(@ProductName)); --Adicionar novo registro INSERT INTO TestTable(CategoryId, ProductName, Price) VALUES (@CategoryId, @ProductName, @Price) END GO
Excluindo um procedimento armazenado em T-SQL - instrução DROP PROCEDURE
Se necessário, você pode excluir o procedimento armazenado, isso é feito usando a instrução PROCEDIMENTO DE QUEDA.
Por exemplo, vamos excluir o procedimento de teste que criamos.
DROP PROCEDURE TestProcedure
Ao deletar procedimentos armazenados, vale lembrar que se o procedimento for referenciado por outros procedimentos ou instruções SQL, após sua exclusão, eles falharão com um erro, pois o procedimento ao qual se referem não existe mais.
Eu tenho tudo, espero que o material tenha sido interessante e útil para você, tchau!
