Função versus procedimento armazenado no SQL Server

Aprendi Funções e Procedimento Armazenado por um bom tempo, mas não sei por que e quando devo usar uma função ou um procedimento armazenado. Eles parecem iguais para mim, talvez porque eu seja meio novato nisso.

Alguém pode me dizer o porquê?

Funções são valores calculados e não podem executar alterações ambientais permanentes em SQL Server(isto é, nenhuma INSERTou UPDATEdeclarações permitidas).

Uma função pode ser usada em linha nas SQLinstruções se retornar um valor escalar ou pode ser associada se retornar um conjunto de resultados.

Um ponto digno de nota nos comentários, que resumem a resposta. Graças a @Sean K Anderson:

As funções seguem a definição de ciência da computação, na medida em que DEVEM retornar um valor e não podem alterar os dados que recebem como parâmetros (os argumentos). As funções não têm permissão para alterar nada, devem ter pelo menos um parâmetro e devem retornar um valor. Os procs armazenados não precisam ter um parâmetro, podem alterar objetos do banco de dados e não precisam retornar um valor.

Como chamar a SQLfunção do procedimento de armazenamento e quando usamos uma função em vez do procedimento armazenado.

Olá amigos, hoje discutiremos Quando usar o procedimento armazenado e quando usar a função. Em equipe simples Se você deseja calcular alguns valores e ele retornará um único valor, portanto, não é necessário:

https://programmingtechtutorial.blogspot.com/2020/01/when-use-storeprocedure-and-when-use.html

A diferença entre SP e UDF está listada abaixo:

+---------------------------------+----------------------------------------+
| Stored Procedure (SP)           | Function (UDF - User Defined           |
|                                 | Function)                              |
+---------------------------------+----------------------------------------+
| SP can return zero , single or  | Function must return a single value    |
| multiple values.                | (which may be a scalar or a table).    |
+---------------------------------+----------------------------------------+
| We can use transaction in SP.   | We can't use transaction in UDF.       |
+---------------------------------+----------------------------------------+
| SP can have input/output        | Only input parameter.                  |
| parameter.                      |                                        |
+---------------------------------+----------------------------------------+
| We can call function from SP.   | We can't call SP from function.        |
+---------------------------------+----------------------------------------+
| We can't use SP in SELECT/      | We can use UDF in SELECT/ WHERE/       |
| WHERE/ HAVING statement.        | HAVING statement.                      |
+---------------------------------+----------------------------------------+
| We can use exception handling   | We can't use Try-Catch block in UDF.   |
| using Try-Catch block in SP.    |                                        |
+---------------------------------+----------------------------------------+

Funções e procedimentos armazenados servem a propósitos separados. Embora não seja a melhor analogia, as funções podem ser vistas literalmente como qualquer outra função que você usaria em qualquer linguagem de programação, mas os procs armazenados são mais parecidos com programas individuais ou como um script em lote.

As funções normalmente têm uma saída e, opcionalmente, entradas. A saída pode ser usada como entrada para outra função (um SQL Server interno como DATEDIFF, LEN, etc) ou como predicado para uma Consulta SQL - por exemplo, SELECT a, b, dbo.MyFunction(c) FROM tableou SELECT a, b, c FROM table WHERE a = dbo.MyFunc(c).

Os procs armazenados são usados ​​para vincular consultas SQL em uma transação e fazer interface com o mundo externo. Estruturas como ADO.NET etc. não podem chamar uma função diretamente, mas podem chamar um proc armazenado diretamente.

Porém, as funções têm um perigo oculto: podem ser mal utilizadas e causar problemas de desempenho bastante desagradáveis: considere esta consulta:

SELECT * FROM dbo.MyTable WHERE col1 = dbo.MyFunction(col2)

Onde MyFunction é declarado como:

CREATE FUNCTION MyFunction (@someValue INTEGER) RETURNS INTEGER
AS
BEGIN
   DECLARE @retval INTEGER

   SELECT localValue 
      FROM dbo.localToNationalMapTable
      WHERE nationalValue = @someValue

   RETURN @retval
END

O que acontece aqui é que a função MyFunction é chamada para todas as linhas da tabela MyTable. Se MyTable tiver 1000 linhas, isso significa mais 1000 consultas ad-hoc no banco de dados. Da mesma forma, se a função for chamada quando especificada na especificação da coluna, a função será chamada para cada linha retornada pelo SELECT.

Então você precisa ter cuidado com as funções de escrita. Se você SELECT de uma tabela em uma função, precisa se perguntar se ela pode ser melhor executada com uma JOIN no processo armazenado pai ou em alguma outra construção SQL (como CASE ... WHEN ... ELSE ... FIM).

Diferenças entre procedimentos armazenados e funções definidas pelo usuário:

• Procedimentos armazenados não podem ser usados ​​nas instruções Select.
• Os procedimentos armazenados oferecem suporte à Resolução de Nome Adiado.
• Os procedimentos armazenados geralmente são usados ​​para executar a lógica de negócios.
• Procedimentos armazenados podem retornar qualquer tipo de dados.
• Os procedimentos armazenados podem aceitar um número maior de parâmetros de entrada do que as funções definidas pelo usuário. Os procedimentos armazenados podem ter até 21.000 parâmetros de entrada.
• Os procedimentos armazenados podem executar o SQL dinâmico.
• Os procedimentos armazenados suportam o tratamento de erros.
• Funções não determinísticas podem ser usadas em procedimentos armazenados.

• Funções definidas pelo usuário podem ser usadas nas instruções Select.
• As funções definidas pelo usuário não oferecem suporte à Resolução de Nome Adiado.
• Funções definidas pelo usuário são geralmente usadas para cálculos.
• Funções definidas pelo usuário devem retornar um valor.
• As funções definidas pelo usuário não podem retornar imagens.
• As funções definidas pelo usuário aceitam números menores de parâmetros de entrada que os procedimentos armazenados. UDFs podem ter até 1.023 parâmetros de entrada.
• Tabelas temporárias não podem ser usadas em funções definidas pelo usuário.
• As funções definidas pelo usuário não podem executar o SQL dinâmico.
• As funções definidas pelo usuário não suportam o tratamento de erros. RAISEERROROU @@ERRORnão são permitidos em UDFs.
• Funções não determinísticas não podem ser usadas em UDFs. Por exemplo, GETDATE()não pode ser usado em UDFs.

Escreva uma função definida pelo usuário quando desejar calcular e retornar um valor para uso em outras instruções SQL; escreva um procedimento armazenado quando desejar, em vez disso, agrupe um conjunto possivelmente complexo de instruções SQL. Esses são dois casos de uso bem diferentes, afinal!

              STORE PROCEDURE                 FUNCTION (USER DEFINED FUNCTION)    
 * Procedure can return 0, single or   | * Function can return only single value   
   multiple values.                    |
                                       |
 * Procedure can have input, output    | * Function  can have only input 
   parameters.                         |   parameters.         
                                       |
 * Procedure cannot be called from     | * Functions can be called from 
   function.                           |   procedure.
                                       |
 * Procedure allows select as well as  | * Function allows only select statement 
   DML statement in it.                |   in it.
                                       |
 * Exception can be handled by         | * Try-catch block cannot be used in a 
   try-catch block in a procedure.     |   function.
                                       |
 * We can go for transaction management| * We can't go for transaction 
   in procedure.                       |   management in function.
                                       |
 * Procedure cannot be utilized in a   | * Function can be embedded in a select 
   select statement                    |   statement.
                                       |
 * Procedure can affect the state      | * Function can not affect the state 
   of database means it can perform    |   of database means it can not    
   CRUD operation on database.         |   perform CRUD operation on 
                                       |   database. 
                                       |
 * Procedure can use temporary tables. | * Function can not use 
                                       |   temporary tables. 
                                       |
 * Procedure can alter the server      | * Function can not alter the  
   environment parameters.             |   environment parameters.
                                       |   
 * Procedure can use when we want      | * Function can use when we want
   instead is to group a possibly-     |   to compute and return a value
   complex set of SQL statements.      |   for use in other SQL 
                                       |   statements.

Diferença básica

A função deve retornar um valor, mas no Procedimento Armazenado é opcional (o Procedimento pode retornar valores zero ou n).

As funções podem ter apenas parâmetros de entrada, enquanto os Procedimentos podem ter parâmetros de entrada / saída.

A função aceita um parâmetro de entrada e é obrigatória, mas o Stored Procedure pode levar até n parâmetros de entrada.

As funções podem ser chamadas a partir de Procedimento, enquanto os Procedimentos não podem ser chamados a partir de Função.

Diferença Avançada

O procedimento permite a instrução SELECT e DML (INSERT / UPDATE / DELETE), enquanto a Function permite apenas a instrução SELECT.

Os procedimentos não podem ser utilizados em uma instrução SELECT, enquanto a Function pode ser incorporada em uma instrução SELECT.

Os procedimentos armazenados não podem ser usados ​​nas instruções SQL em qualquer lugar da seção WHERE / HAVING / SELECT, enquanto Function pode ser.

As funções que retornam tabelas podem ser tratadas como outro conjunto de linhas. Isso pode ser usado em JOINs com outras tabelas.

A função embutida pode ser vista como tendo parâmetros e pode ser usada em JOINs e outras operações de conjunto de linhas.

A exceção pode ser manipulada pelo bloco try-catch em um Procedimento, enquanto o bloco try-catch não pode ser usado em uma Função.

Podemos ir para o Gerenciamento de Transações no Procedimento, enquanto não podemos ir na Função.

fonte

uma função definida pelo usuário é uma ferramenta importante disponível para um programador de servidor sql. Você pode usá-lo em linha em uma instrução SQL como essa

SELECT a, lookupValue(b), c FROM customers 

onde lookupValueserá uma UDF. Esse tipo de funcionalidade não é possível ao usar um procedimento armazenado. Ao mesmo tempo, você não pode fazer certas coisas dentro de uma UDF. O básico a lembrar aqui é que as UDFs:

• não pode criar alterações permanentes
• não pode alterar dados

um procedimento armazenado pode fazer essas coisas.

Para mim, o uso embutido de um UDF é o uso mais importante de um UDF.

Procedimentos armazenados são usados ​​como scripts . Eles executam uma série de comandos para você e você pode agendá-los para execução em determinados horários. Geralmente executa várias instruções DML como INSERT, UPDATE, DELETE etc. ou até SELECT.

Funções são usadas como métodos. Você passa algo e retorna um resultado. Deve ser pequeno e rápido - faz isso na hora. Geralmente usado em uma instrução SELECT.

Procedimento armazenado:

• É como um programa em miniatura no SQL Server.
• Pode ser tão simples quanto uma instrução select ou tão complexo quanto um script longo que adiciona, exclui, atualiza e / ou lê dados de várias tabelas em um banco de dados.
• (É possível implementar loops e cursores, que permitem trabalhar com resultados menores ou operações linha por linha nos dados.)
• Deve ser chamado usando EXECou EXECUTEinstrução
• Retorna variáveis ​​da tabela, mas não podemos usar o OUTparâmetro
• Suporta transações.

Função:

• Não pode ser usado para atualizar, excluir ou adicionar registros ao banco de dados.
• Simplesmente retorna um valor único ou um valor de tabela.

• Só pode ser usado para selecionar registros. No entanto, pode ser chamado com muita facilidade a partir do SQL padrão, como:

  SELECT dbo.functionname('Parameter1')

  ou

  SELECT Name, dbo.Functionname('Parameter1') FROM sysObjects

• Para operações de seleção reutilizáveis ​​simples, as funções podem simplificar o código. Apenas tenha cuidado ao usar JOINcláusulas em suas funções. Se sua função tiver uma JOINcláusula e você a chamar de outra instrução select que retorne vários resultados, essa chamada de função fará JOIN essas tabelas juntas para cada linha retornada no conjunto de resultados. Portanto, embora possam ser úteis para simplificar alguma lógica, também podem ser um gargalo de desempenho se não forem usados ​​corretamente.

• Retorna os valores usando o OUTparâmetro
• Não suporta transações.

Função definida pelo usuário.

1. A função deve retornar um valor.
2. Permitirá apenas instruções Select, não nos permitirá usar instruções DML.
3. Permitirá apenas parâmetros de entrada, não suporta parâmetros de saída.
4. Não nos permitirá usar blocos try-catch.
5. Transações não são permitidas dentro de funções.
6. Podemos usar apenas variáveis ​​de tabela, isso não permitirá o uso de tabelas temporárias.
7. Procedimentos armazenados não podem ser chamados de uma função.
8. As funções podem ser chamadas a partir de uma instrução select.
9. Um UDF pode ser usado na cláusula de junção como um conjunto de resultados.

Procedimento armazenado

1. O procedimento armazenado pode ou não retornar valores.
2. Pode ter instruções de seleção e instruções DML, como inserir, atualizar, excluir e assim por diante
3. Pode ter parâmetros de entrada e saída.
4. Para manipulação de exceção, podemos usar blocos try catch.
5. Pode usar transações dentro de procedimentos armazenados.
6. Pode usar tanto variáveis ​​de tabela quanto tabela temporária.
7. Procedimentos armazenados podem chamar funções.
8. Os procedimentos não podem ser chamados nas instruções Select / Where / Having e assim por diante. A instrução Execute / Exec pode ser usada para chamar / executar o Stored Procedure.
9. Os procedimentos não podem ser usados ​​na cláusula Join

Para decidir quando usar o que os seguintes pontos podem ajudar:

1. Os procedimentos armazenados não podem retornar uma variável de tabela, onde a função pode fazer isso.

2. Você pode usar procedimentos armazenados para alterar os parâmetros do ambiente do servidor, utilizando funções que não podem.

Felicidades

As funções do SQL Server, como cursores, devem ser usadas como sua última arma! Eles têm problemas de desempenho e, portanto, o uso de uma função com valor de tabela deve ser evitado o máximo possível. Falar sobre desempenho é falar de uma tabela com mais de 1.000.000 de registros hospedados em um servidor em um hardware de classe média; caso contrário, você não precisa se preocupar com o desempenho causado pelas funções.

1. Nunca use uma função para retornar um conjunto de resultados para um código externo (como ADO.Net)
2. Use a combinação de visualizações / procs armazenados o máximo possível. você pode se recuperar de problemas futuros de desempenho de crescimento usando as sugestões que o DTA (Database Tuning Adviser) forneceria (como visualizações e estatísticas indexadas) - às vezes!

para obter mais referências, consulte: http://databases.aspfaq.com/database/should-i-use-a-view-a-stored-procedure-or-a-user-defined-function.html

Comece com funções que retornam um único valor. O bom é que você pode colocar o código usado com frequência em uma função e retorná-lo como uma coluna em um conjunto de resultados.

Em seguida, você pode usar uma função para uma lista parametrizada de cidades. dbo.GetCitiesIn ("NY") Isso retorna uma tabela que pode ser usada como uma associação.

É uma maneira de organizar o código. Saber quando algo é reutilizável e quando é uma perda de tempo é algo que só se obtém por tentativa, erro e experiência.

Além disso, as funções são uma boa ideia no SQL Server. Eles são mais rápidos e podem ser bastante poderosos. Seleciona inline e direta. Cuidado para não usar demais.

Aqui está um motivo prático para preferir funções a procedimentos armazenados. Se você tiver um procedimento armazenado que precise dos resultados de outro procedimento armazenado, precisará usar uma instrução insert-exec. Isso significa que você precisa criar uma tabela temporária e usar uma execinstrução para inserir os resultados do procedimento armazenado na tabela temporária. É bagunçado. Um problema com isso é que os executivos de inserção não podem ser aninhados .

Se você estiver preso a procedimentos armazenados que chamam outros procedimentos armazenados, você pode se deparar com isso. Se o procedimento armazenado aninhado simplesmente retornar um conjunto de dados, ele poderá ser substituído por uma função com valor de tabela e você não receberá mais esse erro.

( esse é outro motivo pelo qual devemos manter a lógica de negócios fora do banco de dados )

• É obrigatório que Function retorne um valor enquanto não for para procedimento armazenado.
• Instruções Select aceitas apenas no UDF, enquanto instruções DML não forem necessárias.
• O procedimento armazenado aceita qualquer instrução, bem como instruções DML.
• UDF permite apenas entradas e não saídas.
• O procedimento armazenado permite entradas e saídas.
• Blocos de captura não podem ser usados ​​no UDF, mas podem ser usados ​​no procedimento armazenado.
• Nenhuma transação é permitida em funções no UDF, mas no procedimento armazenado elas são permitidas.
• Somente variáveis ​​de tabela podem ser usadas em UDF e não em tabelas temporárias.
• O procedimento armazenado permite variáveis ​​de tabela e tabelas temporárias.
• O UDF não permite que procedimentos armazenados sejam chamados a partir de funções, enquanto procedimentos armazenados permitem a chamada de funções.
• O UDF é usado na cláusula de junção, enquanto os procedimentos armazenados não podem ser usados ​​na cláusula de junção.
• O procedimento armazenado sempre permitirá retornar a zero. A UDF, pelo contrário, tem valores que devem retornar a um ponto predeterminado.

• As funções podem ser usadas em uma instrução select onde os procedimentos não podem.

• O procedimento armazenado usa os parâmetros de entrada e saída, mas o Functions usa apenas parâmetros de entrada.

• As funções não podem retornar valores do tipo texto, ntexto, imagem e registros de data e hora, sempre que possível.

• As funções podem ser usadas como tipos de dados definidos pelo usuário na tabela create, mas os procedimentos não.

*** Por exemplo: -criar table <tablename>(name varchar(10),salary getsal(name))

Aqui getsal é uma função definida pelo usuário que retorna um tipo de salário, quando a tabela é criada, nenhum armazenamento é alocado para o tipo de salário e a função getsal também não é executada. Mas, quando estamos buscando alguns valores dessa tabela, a função getsal é executada e o return Tipo é retornado como o conjunto de resultados.

Sei que essa é uma pergunta muito antiga, mas não vejo um aspecto crucial mencionado em nenhuma das respostas: entrar no plano de consulta.

Funções podem ser ...

1. Escalar:

   CREATE FUNCTION ... RETURNS scalar_type AS BEGIN ... END

2. Multi-instrução com valor de tabela:

   CREATE FUNCTION ... RETURNS @r TABLE(...) AS BEGIN ... END

3. Com valor de tabela em linha:

   CREATE FUNCTION ... RETURNS TABLE AS RETURN SELECT ...

O terceiro tipo (com valor de tabela embutido) é tratado pelo otimizador de consulta essencialmente como visualizações (parametrizadas), o que significa que a referência à função da sua consulta é semelhante a copiar e colar o corpo SQL da função (sem realmente copiar e colar), levando aos seguintes benefícios:

• O planejador de consultas pode otimizar a execução da função inline da mesma maneira que faria com qualquer outra subconsulta (por exemplo, eliminar colunas não utilizadas, empurrar predicados para baixo, escolher estratégias diferentes de JOIN etc.).
• A combinação de várias funções embutidas não requer materializar o resultado do primeiro antes de alimentá-lo para o próximo.

O exposto acima pode levar a economias de desempenho potencialmente significativas, especialmente ao combinar vários níveis de funções.

NOTA: Parece que o SQL Server 2019 também apresentará alguma forma de função escalar .

No SQL Server, funções e procedimento armazenado são dois tipos diferentes de entidades.

Função: no banco de dados SQL Server, as funções são usadas para executar algumas ações e a ação retorna um resultado imediatamente. Funções são dois tipos:

1. Sistema definido

2. Usuário definido

Procedimentos armazenados: No SQL Server, os procedimentos armazenados são armazenados no servidor e podem retornar zero, valores únicos e múltiplos. Procedimentos armazenados são dois tipos:

1. Procedimentos armazenados do sistema
2. Procedimentos definidos pelo usuário