Fonction vs procédure stockée dans SQL Server

J'apprends les fonctions et la procédure stockée depuis un certain temps, mais je ne sais pas pourquoi et quand je devrais utiliser une fonction ou une procédure stockée. Ils me ressemblent, peut-être parce que je suis un peu novice à ce sujet.

Quelqu'un peut-il me dire pourquoi?

Les fonctions sont des valeurs calculées et ne peuvent pas effectuer de modifications environnementales permanentes SQL Server(c.- à -d. Aucune instruction INSERTou UPDATEinstruction n'est autorisée).

Une fonction peut être utilisée en ligne dans des SQLinstructions si elle renvoie une valeur scalaire ou peut être jointe si elle renvoie un jeu de résultats.

Un point à noter dans les commentaires, qui résument la réponse. Merci à @Sean K Anderson:

Les fonctions suivent la définition de l'informatique dans la mesure où elles DOIVENT retourner une valeur et ne peuvent pas modifier les données qu'elles reçoivent en tant que paramètres (les arguments). Les fonctions ne sont pas autorisées à modifier quoi que ce soit, doivent avoir au moins un paramètre et doivent renvoyer une valeur. Les proc stockés n'ont pas besoin d'avoir un paramètre, peuvent changer les objets de base de données et n'ont pas besoin de retourner une valeur.

Comment appeler SQL fonction à partir d'une procédure de stockage et quand nous utilisons une fonction au lieu d'une procédure stockée.

Salut les amis, aujourd'hui, nous allons discuter du moment où utiliser la procédure stockée et quand utiliser la fonction. En équipe simple Si vous souhaitez calculer certaines valeurs et qu'il renverra une seule valeur, ce n'est donc pas obligatoire:

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

La différence entre SP et UDF est indiquée ci-dessous:

+---------------------------------+----------------------------------------+
| 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.    |                                        |
+---------------------------------+----------------------------------------+

Les fonctions et les procédures stockées ont des objectifs distincts. Bien que ce ne soit pas la meilleure analogie, les fonctions peuvent être vues littéralement comme n'importe quelle autre fonction que vous utiliseriez dans n'importe quel langage de programmation, mais les proc stockés sont plus comme des programmes individuels ou un script batch.

Les fonctions ont normalement une sortie et éventuellement des entrées. La sortie peut ensuite être utilisée comme entrée vers une autre fonction (un SQL Server intégré tel que DATEDIFF, LEN, etc.) ou comme prédicat pour une requête SQL - par exemple, SELECT a, b, dbo.MyFunction(c) FROM tableouSELECT a, b, c FROM table WHERE a = dbo.MyFunc(c) .

Les proc stockés sont utilisés pour lier les requêtes SQL ensemble dans une transaction, et s'interfacer avec le monde extérieur. Les cadres tels que ADO.NET, etc. ne peuvent pas appeler directement une fonction, mais ils peuvent appeler directement un proc stocké.

Les fonctions ont cependant un danger caché: elles peuvent être mal utilisées et provoquer des problèmes de performances plutôt désagréables: considérez cette requête:

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

Où MyFunction est déclaré comme:

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

   SELECT localValue 
      FROM dbo.localToNationalMapTable
      WHERE nationalValue = @someValue

   RETURN @retval
END

Ce qui se passe ici, c'est que la fonction MyFunction est appelée pour chaque ligne de la table MyTable. Si MyTable a 1000 lignes, alors c'est encore 1000 requêtes ad hoc sur la base de données. De même, si la fonction est appelée lorsqu'elle est spécifiée dans la spécification de colonne, la fonction sera appelée pour chaque ligne renvoyée par SELECT.

Vous devez donc faire attention aux fonctions d'écriture. Si vous effectuez SELECT à partir d'une table dans une fonction, vous devez vous demander s'il peut être mieux exécuté avec un JOIN dans le proc stocké parent ou une autre construction SQL (comme CASE ... WHEN ... ELSE ... FIN).

Différences entre les procédures stockées et les fonctions définies par l'utilisateur:

• Les procédures stockées ne peuvent pas être utilisées dans les instructions Select.
• Les procédures stockées prennent en charge la résolution de noms différés.
• Les procédures stockées sont généralement utilisées pour exécuter la logique métier.
• Les procédures stockées peuvent renvoyer n'importe quel type de données.
• Les procédures stockées peuvent accepter un plus grand nombre de paramètres d'entrée que les fonctions définies par l'utilisateur. Les procédures stockées peuvent avoir jusqu'à 21 000 paramètres d'entrée.
• Les procédures stockées peuvent exécuter Dynamic SQL.
• Les procédures stockées prennent en charge la gestion des erreurs.
• Des fonctions non déterministes peuvent être utilisées dans des procédures stockées.

• Les fonctions définies par l'utilisateur peuvent être utilisées dans les instructions Select.
• Les fonctions définies par l'utilisateur ne prennent pas en charge la résolution de nom différée.
• Les fonctions définies par l'utilisateur sont généralement utilisées pour les calculs.
• Les fonctions définies par l'utilisateur doivent renvoyer une valeur.
• Les fonctions définies par l'utilisateur ne peuvent pas renvoyer d'images.
• Les fonctions définies par l'utilisateur acceptent un plus petit nombre de paramètres d'entrée que les procédures stockées. Les FDU peuvent avoir jusqu'à 1 023 paramètres d'entrée.
• Les tables temporaires ne peuvent pas être utilisées dans les fonctions définies par l'utilisateur.
• Les fonctions définies par l'utilisateur ne peuvent pas exécuter Dynamic SQL.
• Les fonctions définies par l'utilisateur ne prennent pas en charge la gestion des erreurs. RAISEERROROU @@ERRORne sont pas autorisés dans les FDU.
• Les fonctions non déterministes ne peuvent pas être utilisées dans les FDU. Par exemple, GETDATE()ne peut pas être utilisé dans les FDU.

Écrivez une fonction définie par l'utilisateur lorsque vous souhaitez calculer et renvoyer une valeur à utiliser dans d'autres instructions SQL; écrire une procédure stockée lorsque vous le souhaitez consiste à regrouper un ensemble d'instructions SQL éventuellement complexe. Ce sont deux cas d'utilisation assez différents, après tout!

              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.

Différence de base

La fonction doit renvoyer une valeur mais dans la procédure stockée, elle est facultative (la procédure peut retourner zéro ou n valeurs).

Les fonctions ne peuvent avoir que des paramètres d'entrée alors que les procédures peuvent avoir des paramètres d'entrée / sortie.

La fonction prend un paramètre d'entrée, elle est obligatoire mais la procédure stockée peut prendre de o à n paramètres d'entrée.

Les fonctions peuvent être appelées depuis Procedure alors que les procédures ne peuvent pas être appelées depuis Function.

Différence avancée

La procédure autorise l'instruction SELECT ainsi que l'instruction DML (INSERT / UPDATE / DELETE), tandis que la fonction n'autorise que l'instruction SELECT.

Les procédures ne peuvent pas être utilisées dans une instruction SELECT tandis que Function peut être incorporée dans une instruction SELECT.

Les procédures stockées ne peuvent pas être utilisées dans les instructions SQL n'importe où dans la section WHERE / HAVING / SELECT alors que Function peut l'être.

Les fonctions qui renvoient des tables peuvent être traitées comme un autre ensemble de lignes. Cela peut être utilisé dans JOINs avec d'autres tables.

La fonction en ligne peut être considérée comme une vue qui accepte des paramètres et peut être utilisée dans des JOIN et d'autres opérations d'ensemble de lignes.

L'exception peut être gérée par le bloc try-catch dans une procédure alors que le bloc try-catch ne peut pas être utilisé dans une fonction.

Nous pouvons opter pour la gestion des transactions dans la procédure alors que nous ne pouvons pas aller dans la fonction.

la source

une fonction définie par l'utilisateur est un outil important à la disposition d'un programmeur de serveur SQL. Vous pouvez l'utiliser en ligne dans une instruction SQL comme ceci

SELECT a, lookupValue(b), c FROM customers 

où lookupValuesera un UDF. Ce type de fonctionnalité n'est pas possible lors de l'utilisation d'une procédure stockée. En même temps, vous ne pouvez pas faire certaines choses à l'intérieur d'un UDF. La chose fondamentale à retenir ici est que les UDF:

• ne peut pas créer de changements permanents
• ne peut pas modifier les données

une procédure stockée peut faire ces choses.

Pour moi, l'utilisation en ligne d'un UDF est l'utilisation la plus importante d'un UDF.

Les procédures stockées sont utilisées comme scripts . Ils exécutent une série de commandes pour vous et vous pouvez les planifier pour s'exécuter à certains moments. Exécute généralement plusieurs instructions DML comme INSERT, UPDATE, DELETE, etc. ou même SELECT.

Les fonctions sont utilisées comme méthodes. Vous lui passez quelque chose et cela renvoie un résultat. Devrait être petit et rapide - le fait à la volée. Généralement utilisé dans une instruction SELECT.

Procédure stockée:

• C'est comme un programme miniature dans SQL Server.
• Peut être aussi simple qu'une instruction select, ou aussi complexe qu'un long script qui ajoute, supprime, met à jour et / ou lit les données de plusieurs tables dans une base de données.
• (Peut implémenter des boucles et des curseurs, qui vous permettent de travailler avec des résultats plus petits ou des opérations ligne par ligne sur les données.)
• Doit être appelé en utilisant EXECouEXECUTE instruction .
• Renvoie des variables de table, mais nous ne pouvons pas utiliser OUT paramètre.
• Prend en charge les transactions.

Une fonction:

• Ne peut pas être utilisé pour mettre à jour, supprimer ou ajouter des enregistrements à la base de données.
• Renvoie simplement une valeur unique ou une valeur de table.

• Ne peut être utilisé que pour sélectionner des enregistrements. Cependant, il peut être appelé très facilement à partir de SQL standard, comme:

  SELECT dbo.functionname('Parameter1')

  ou

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

• Pour des opérations de sélection réutilisables simples, les fonctions peuvent simplifier le code. Méfiez-vous simplement de l'utilisation de JOINclauses dans vos fonctions. Si votre fonction a une JOINclause et que vous l'appelez à partir d'une autre instruction select qui renvoie plusieurs résultats, cet appel de fonction JOIN regroupera ces tables pour chaque ligne renvoyée dans le jeu de résultats. Ainsi, bien qu'ils puissent être utiles pour simplifier une certaine logique, ils peuvent également être un goulot d'étranglement en termes de performances s'ils ne sont pas utilisés correctement.

• Renvoie les valeurs en utilisant OUT paramètre.
• Ne prend pas en charge les transactions.

Fonction définie par l'utilisateur.

1. La fonction doit renvoyer une valeur.
2. Autorise uniquement les instructions Select, il ne nous permet pas d'utiliser des instructions DML.
3. Il autorise uniquement les paramètres d'entrée, ne prend pas en charge les paramètres de sortie.
4. Cela ne nous permettra pas d'utiliser des blocs try-catch.
5. Les transactions ne sont pas autorisées dans les fonctions.
6. Nous ne pouvons utiliser que des variables de table, cela ne permettra pas d'utiliser des tables temporaires.
7. Les procédures stockées ne peuvent pas être appelées à partir d'une fonction.
8. Les fonctions peuvent être appelées à partir d'une instruction select.
9. Un UDF peut être utilisé dans la clause join en tant que jeu de résultats.

Procédure stockée

1. La procédure stockée peut ou non renvoyer des valeurs.
2. Peut avoir des instructions de sélection ainsi que des instructions DML telles que l'insertion, la mise à jour, la suppression, etc.
3. Il peut avoir des paramètres d'entrée et de sortie.
4. Pour la gestion des exceptions, nous pouvons utiliser des blocs try catch.
5. Peut utiliser des transactions dans les procédures stockées.
6. Peut utiliser à la fois des variables de table et une table temporaire.
7. Les procédures stockées peuvent appeler des fonctions.
8. Les procédures ne peuvent pas être appelées à partir des instructions Select / Where / Have et ainsi de suite. L'instruction Execute / Exec peut être utilisée pour appeler / exécuter la procédure stockée.
9. Les procédures ne peuvent pas être utilisées dans la clause Join

Pour décider quand utiliser ce que les points suivants pourraient aider:

1. Les procédures stockées ne peuvent pas renvoyer une variable de table alors que la fonction peut le faire.

2. Vous pouvez utiliser des procédures stockées pour modifier les paramètres de l'environnement du serveur alors que vous ne pouvez pas utiliser des fonctions.

à votre santé

Les fonctions SQL Server, comme les curseurs, sont destinées à être utilisées comme votre dernière arme! Ils ont des problèmes de performances et, par conséquent, l'utilisation d'une fonction table doit être évitée autant que possible. Parler de performance, c'est parler d'une table avec plus de 1 000 000 d'enregistrements hébergés sur un serveur sur un matériel de classe moyenne; sinon, vous n'avez pas à vous soucier de la perte de performances causée par les fonctions.

1. N'utilisez jamais une fonction pour renvoyer un jeu de résultats vers un code externe (comme ADO.Net)
2. Utilisez autant que possible la combinaison vues / proc stockés. vous pouvez récupérer des futurs problèmes de croissance en utilisant les suggestions que DTA (Database Tuning Adviser) vous donnerait (comme les vues indexées et les statistiques) - parfois!

pour plus d'informations, voir: http://databases.aspfaq.com/database/should-i-use-a-view-a-stored-procedure-or-a-user-defined-function.html

Commencez avec des fonctions qui renvoient une seule valeur. La bonne chose est que vous pouvez mettre du code fréquemment utilisé dans une fonction et les renvoyer sous forme de colonne dans un jeu de résultats.

Ensuite, vous pouvez utiliser une fonction pour une liste paramétrée de villes. dbo.GetCitiesIn ("NY") Cela renvoie une table qui peut être utilisée comme jointure.

C'est une façon d'organiser le code. Savoir quand quelque chose est réutilisable et quand c'est une perte de temps n'est acquis que par essais et erreurs et par expérience.

En outre, les fonctions sont une bonne idée dans SQL Server. Ils sont plus rapides et peuvent être assez puissants. Sélection en ligne et directe. Attention à ne pas abuser.

Voici une raison pratique de préférer les fonctions aux procédures stockées. Si vous avez une procédure stockée qui a besoin des résultats d'une autre procédure stockée, vous devez utiliser une instruction insert-exec. Cela signifie que vous devez créer une table temporaire et utiliser une execinstruction pour insérer les résultats de la procédure stockée dans la table temporaire. C'est désordonné. Un problème avec cela est que les insert-execs ne peuvent pas être imbriqués .

Si vous êtes bloqué avec des procédures stockées qui appellent d'autres procédures stockées, vous pouvez rencontrer cela. Si la procédure stockée imbriquée renvoie simplement un ensemble de données, il peut être remplacé par une fonction table et vous n'obtiendrez plus cette erreur.

( c'est encore une autre raison pour laquelle nous devons garder la logique métier hors de la base de données )

• Il est obligatoire pour Function de renvoyer une valeur alors que ce n'est pas pour la procédure stockée.
• Sélectionnez les instructions uniquement acceptées dans UDF alors que les instructions DML ne sont pas requises.
• La procédure stockée accepte toutes les instructions ainsi que les instructions DML.
• UDF autorise uniquement les entrées et non les sorties.
• La procédure stockée permet à la fois les entrées et les sorties.
• Les blocs de capture ne peuvent pas être utilisés dans UDF mais peuvent être utilisés dans une procédure stockée.
• Aucune transaction n'est autorisée dans les fonctions dans UDF mais dans la procédure stockée, elles sont autorisées.
• Seules les variables de table peuvent être utilisées dans UDF et non les tables temporaires.
• La procédure stockée permet à la fois les variables de table et les tables temporaires.
• UDF ne permet pas d'appeler des procédures stockées à partir de fonctions tandis que les procédures stockées permettent d'appeler des fonctions.
• UDF est utilisé dans la clause join alors que les procédures stockées ne peuvent pas être utilisées dans la clause join.
• La procédure stockée permettra toujours de revenir à zéro. UDF, au contraire, a des valeurs qui doivent revenir à un point prédéterminé.

• Les fonctions peuvent être utilisées dans une instruction select, contrairement aux procédures.

• La procédure stockée prend à la fois les paramètres d'entrée et de sortie, mais Functions ne prend que les paramètres d'entrée.

• Les fonctions ne peuvent pas renvoyer des valeurs de type texte, ntext, image et horodatages là où les procédures le peuvent.

• Les fonctions peuvent être utilisées comme types de données définis par l'utilisateur dans la table de création, mais pas les procédures.

*** Par exemple: -créer table <tablename>(name varchar(10),salary getsal(name))

Ici, getsal est une fonction définie par l'utilisateur qui renvoie un type de salaire, lorsque la table est créée, aucun stockage n'est alloué pour le type de salaire, et la fonction getsal n'est également pas exécutée, mais lorsque nous récupérons certaines valeurs de cette table, la fonction getsal est exécutée et le return Type est renvoyé comme jeu de résultats.

Je me rends compte que c'est une très vieille question, mais je ne vois aucun aspect crucial mentionné dans aucune des réponses: l'inclusion dans le plan de requête.

Les fonctions peuvent être ...

1. Scalaire:

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

2. Valeur table multi-instructions:

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

3. Valeur de table en ligne:

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

Le troisième type (valeur de table en ligne) est traité par l'optimiseur de requête essentiellement comme des vues (paramétrées), ce qui signifie que référencer la fonction à partir de votre requête est similaire au copier-coller du corps SQL de la fonction (sans réellement copier-coller), ce qui entraîne aux avantages suivants:

• Le planificateur de requêtes peut optimiser l'exécution de la fonction en ligne comme il le ferait pour toute autre sous-requête (par exemple, éliminer les colonnes inutilisées, pousser les prédicats vers le bas, choisir différentes stratégies JOIN, etc.).
• La combinaison de plusieurs fonctions en ligne ne nécessite pas de matérialiser le résultat de la première avant de le transmettre à la suivante.

Ce qui précède peut entraîner des économies de performances potentiellement importantes, en particulier lors de la combinaison de plusieurs niveaux de fonctions.

REMARQUE: Il semblerait que SQL Server 2019 introduira également une certaine forme de fonction scalaire en ligne .

Dans SQL Server, les fonctions et la procédure stockée sont deux types d'entités différents.

Fonction: dans la base de données SQL Server, les fonctions sont utilisées pour effectuer certaines actions et l'action renvoie immédiatement un résultat. Les fonctions sont de deux types:

1. Système défini

2. Défini par l'utilisateur

Procédures stockées: dans SQL Server, les procédures stockées sont stockées sur le serveur et il peut renvoyer zéro, une seule et plusieurs valeurs. Les procédures stockées sont de deux types:

1. Procédures stockées système
2. Procédures définies par l'utilisateur