Funktion vs. gespeicherte Prozedur in SQL Server

Ich habe schon eine ganze Weile Funktionen und gespeicherte Prozeduren gelernt, aber ich weiß nicht, warum und wann ich eine Funktion oder eine gespeicherte Prozedur verwenden soll. Sie sehen für mich gleich aus, vielleicht weil ich ein bisschen ein Neuling bin.

Kann mir jemand sagen warum?

Funktionen sind berechnete Werte und können keine dauerhaften Umgebungsänderungen an SQL Server(dh keine INSERToder UPDATEAnweisungen zulässig) durchführen.

Eine Funktion kann in SQLAnweisungen inline verwendet werden , wenn sie einen Skalarwert zurückgibt, oder kann verknüpft werden, wenn sie eine Ergebnismenge zurückgibt.

Ein erwähnenswerter Punkt aus Kommentaren, die die Antwort zusammenfassen. Vielen Dank an @Sean K Anderson:

Funktionen folgen der Definition der Informatik, indem sie einen Wert zurückgeben MÜSSEN und die Daten, die sie als Parameter erhalten (die Argumente), nicht ändern können. Funktionen dürfen nichts ändern, müssen mindestens einen Parameter haben und einen Wert zurückgeben. Gespeicherte Prozesse müssen keinen Parameter haben, können Datenbankobjekte ändern und müssen keinen Wert zurückgeben.

Aufrufen der SQLFunktion aus der Speicherprozedur und Verwenden einer Funktion anstelle der gespeicherten Prozedur.

Hallo Freunde, heute werden wir besprechen, wann die gespeicherte Prozedur verwendet werden soll und wann die Funktion verwendet werden soll. In einem einfachen Team Wenn Sie einige Werte berechnen möchten und ein einzelner Wert zurückgegeben wird, ist dies nicht erforderlich:

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

Der Unterschied zwischen SP und UDF ist unten aufgeführt:

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

Funktionen und gespeicherte Prozeduren dienen getrennten Zwecken. Obwohl dies nicht die beste Analogie ist, können Funktionen buchstäblich als jede andere Funktion angesehen werden, die Sie in einer beliebigen Programmiersprache verwenden würden. Gespeicherte Prozesse ähneln jedoch eher einzelnen Programmen oder einem Batch-Skript.

Funktionen haben normalerweise einen Ausgang und optional Eingänge. Die Ausgabe kann dann als Eingabe für eine andere Funktion (ein integrierter SQL Server wie DATEDIFF, LEN usw.) oder als Prädikat für eine SQL-Abfrage verwendet werden - z . B. SELECT a, b, dbo.MyFunction(c) FROM tableoder SELECT a, b, c FROM table WHERE a = dbo.MyFunc(c).

Gespeicherte Prozesse werden verwendet, um SQL-Abfragen in einer Transaktion zusammenzubinden und eine Schnittstelle zur Außenwelt herzustellen. Frameworks wie ADO.NET usw. können eine Funktion nicht direkt aufrufen, aber sie können einen gespeicherten Prozess direkt aufrufen.

Funktionen bergen jedoch eine versteckte Gefahr: Sie können missbraucht werden und ziemlich unangenehme Leistungsprobleme verursachen: Betrachten Sie diese Abfrage:

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

Wo MyFunction deklariert ist als:

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

   SELECT localValue 
      FROM dbo.localToNationalMapTable
      WHERE nationalValue = @someValue

   RETURN @retval
END

Was hier passiert ist, dass die Funktion MyFunction für jede Zeile in der Tabelle MyTable aufgerufen wird. Wenn MyTable 1000 Zeilen enthält, sind dies weitere 1000 Ad-hoc-Abfragen für die Datenbank. Wenn die Funktion aufgerufen wird, wenn sie in der Spaltenspezifikation angegeben ist, wird die Funktion für jede von SELECT zurückgegebene Zeile aufgerufen.

Sie müssen also vorsichtig mit den Schreibfunktionen umgehen. Wenn Sie SELECT aus einer Tabelle in einer Funktion ausführen, müssen Sie sich fragen, ob dies mit einem JOIN im übergeordneten gespeicherten Prozess oder einem anderen SQL-Konstrukt (z. B. CASE ... WHEN ... ELSE ...) besser ausgeführt werden kann. ENDE).

Unterschiede zwischen gespeicherten Prozeduren und benutzerdefinierten Funktionen:

• Gespeicherte Prozeduren können in Select-Anweisungen nicht verwendet werden.
• Gespeicherte Prozeduren unterstützen die Auflösung verzögerter Namen.
• Gespeicherte Prozeduren werden im Allgemeinen zur Durchführung von Geschäftslogik verwendet.
• Gespeicherte Prozeduren können jeden Datentyp zurückgeben.
• Gespeicherte Prozeduren können eine größere Anzahl von Eingabeparametern akzeptieren als benutzerdefinierte Funktionen. Gespeicherte Prozeduren können bis zu 21.000 Eingabeparameter haben.
• Gespeicherte Prozeduren können Dynamic SQL ausführen.
• Gespeicherte Prozeduren unterstützen die Fehlerbehandlung.
• Nicht deterministische Funktionen können in gespeicherten Prozeduren verwendet werden.

• Benutzerdefinierte Funktionen können in Select-Anweisungen verwendet werden.
• Benutzerdefinierte Funktionen unterstützen die Auflösung verzögerter Namen nicht.
• Benutzerdefinierte Funktionen werden im Allgemeinen für Berechnungen verwendet.
• Benutzerdefinierte Funktionen sollten einen Wert zurückgeben.
• Benutzerdefinierte Funktionen können keine Bilder zurückgeben.
• Benutzerdefinierte Funktionen akzeptieren eine geringere Anzahl von Eingabeparametern als gespeicherte Prozeduren. UDFs können bis zu 1.023 Eingabeparameter haben.
• Temporäre Tabellen können nicht in benutzerdefinierten Funktionen verwendet werden.
• Benutzerdefinierte Funktionen können Dynamic SQL nicht ausführen.
• Benutzerdefinierte Funktionen unterstützen keine Fehlerbehandlung. RAISEERRORODER @@ERRORsind in UDFs nicht zulässig.
• Nicht deterministische Funktionen können in UDFs nicht verwendet werden. Zum Beispiel GETDATE()kann nicht in SEF verwendet werden.

Schreiben Sie eine benutzerdefinierte Funktion, wenn Sie einen Wert zur Verwendung in anderen SQL-Anweisungen berechnen und zurückgeben möchten. Schreiben Sie stattdessen eine gespeicherte Prozedur, um einen möglicherweise komplexen Satz von SQL-Anweisungen zu gruppieren. Immerhin sind dies zwei ziemlich unterschiedliche Anwendungsfälle!

              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.

Grundlegender Unterschied

Die Funktion muss einen Wert zurückgeben, ist jedoch in der gespeicherten Prozedur optional (die Prozedur kann Null- oder n-Werte zurückgeben).

Funktionen können nur Eingabeparameter haben, während Prozeduren Eingabe- / Ausgabeparameter haben können.

Die Funktion benötigt einen Eingabeparameter. Dies ist obligatorisch, die gespeicherte Prozedur kann jedoch bis zu n Eingabeparameter umfassen.

Funktionen können über die Prozedur aufgerufen werden, während Prozeduren nicht über die Funktion aufgerufen werden können.

Fortschritt Unterschied

Die Prozedur erlaubt sowohl die SELECT- als auch die DML-Anweisung (INSERT / UPDATE / DELETE), während die Funktion nur die SELECT-Anweisung zulässt.

Prozeduren können nicht in einer SELECT-Anweisung verwendet werden, während Function in eine SELECT-Anweisung eingebettet werden kann.

Gespeicherte Prozeduren können in den SQL-Anweisungen nirgendwo im Abschnitt WHERE / HAVING / SELECT verwendet werden, wohingegen Function sein kann.

Funktionen, die Tabellen zurückgeben, können als ein anderes Rowset behandelt werden. Dies kann in JOINs mit anderen Tabellen verwendet werden.

Inline-Funktionen können jedoch als Ansichten verwendet werden, die Parameter annehmen und in JOINs und anderen Rowset-Vorgängen verwendet werden können.

Die Ausnahme kann von einem try-catch-Block in einer Prozedur behandelt werden, während der try-catch-Block in einer Funktion nicht verwendet werden kann.

Wir können Transaktionsmanagement in Prozedur wählen, während wir nicht in Funktion gehen können.

Quelle

Eine benutzerdefinierte Funktion ist ein wichtiges Tool, das einem SQL Server-Programmierer zur Verfügung steht. Sie können es in einer solchen SQL-Anweisung inline verwenden

SELECT a, lookupValue(b), c FROM customers 

Wo lookupValuewird eine UDF sein. Diese Art von Funktionalität ist bei Verwendung einer gespeicherten Prozedur nicht möglich. Gleichzeitig können Sie bestimmte Dinge in einer UDF nicht ausführen. Das Grundlegende, an das man sich hier erinnern sollte, ist, dass UDFs:

• kann keine dauerhaften Änderungen erstellen
• Daten können nicht geändert werden

Eine gespeicherte Prozedur kann diese Dinge tun.

Für mich ist die Inline-Verwendung einer UDF die wichtigste Verwendung einer UDF.

Gespeicherte Prozeduren werden als Skripte verwendet . Sie führen eine Reihe von Befehlen für Sie aus, und Sie können festlegen, dass sie zu bestimmten Zeiten ausgeführt werden. Führt normalerweise mehrere DML-Anweisungen wie INSERT, UPDATE, DELETE usw. oder sogar SELECT aus.

Funktionen werden als Methoden verwendet. Sie übergeben etwas und es gibt ein Ergebnis zurück. Sollte klein und schnell sein - macht es im laufenden Betrieb. Wird normalerweise in einer SELECT-Anweisung verwendet.

Gespeicherte Prozedur:

• Ist wie ein Miniaturprogramm in SQL Server.
• Kann so einfach wie eine select-Anweisung oder so komplex wie ein langes Skript sein, das Daten aus mehreren Tabellen in einer Datenbank hinzufügt, löscht, aktualisiert und / oder liest.
• (Kann Schleifen und Cursor implementieren, mit denen Sie mit kleineren Ergebnissen oder zeilenweisen Operationen an Daten arbeiten können.)
• Sollte mit EXECoder EXECUTEAnweisung aufgerufen werden .
• Gibt Tabellenvariablen zurück, aber wir können keine OUTParameter verwenden.
• Unterstützt Transaktionen.

Funktion:

• Kann nicht zum Aktualisieren, Löschen oder Hinzufügen von Datensätzen zur Datenbank verwendet werden.
• Gibt einfach einen einzelnen Wert oder einen Tabellenwert zurück.

• Kann nur zur Auswahl von Datensätzen verwendet werden. Es kann jedoch sehr einfach aus Standard-SQL heraus aufgerufen werden, z.

  SELECT dbo.functionname('Parameter1')

  oder

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

• Für einfache wiederverwendbare Auswahlvorgänge können Funktionen den Code vereinfachen. Seien Sie vorsichtig, wenn Sie JOINKlauseln in Ihren Funktionen verwenden. Wenn Ihre Funktion eine JOINKlausel enthält und Sie sie von einer anderen select-Anweisung aus aufrufen, die mehrere Ergebnisse zurückgibt, werden bei diesem Funktionsaufruf JOIN diese Tabellen für jede in der Ergebnismenge zurückgegebene Zeile zusammengefasst . Obwohl sie bei der Vereinfachung einiger Logik hilfreich sein können, können sie auch einen Leistungsengpass darstellen, wenn sie nicht ordnungsgemäß verwendet werden.

• Gibt die Werte mit dem OUTParameter zurück.
• Unterstützt keine Transaktionen.

Benutzerdefinierte Funktion.

1. Die Funktion muss einen Wert zurückgeben.
2. Erlaubt nur Select-Anweisungen, es erlaubt uns nicht, DML-Anweisungen zu verwenden.
3. Es werden nur Eingabeparameter zugelassen, Ausgabeparameter werden nicht unterstützt.
4. Es erlaubt uns nicht, Try-Catch-Blöcke zu verwenden.
5. Transaktionen sind innerhalb von Funktionen nicht zulässig.
6. Wir können nur Tabellenvariablen verwenden, temporäre Tabellen können nicht verwendet werden.
7. Gespeicherte Prozeduren können nicht von einer Funktion aufgerufen werden.
8. Funktionen können über eine select-Anweisung aufgerufen werden.
9. Eine UDF kann in der Join-Klausel als Ergebnismenge verwendet werden.

Gespeicherte Prozedur

1. Die gespeicherte Prozedur kann Werte zurückgeben oder nicht.
2. Kann sowohl ausgewählte Anweisungen als auch DML-Anweisungen wie Einfügen, Aktualisieren, Löschen usw. enthalten
3. Es kann sowohl Eingabe- als auch Ausgabeparameter haben.
4. Für die Ausnahmebehandlung können wir try catch-Blöcke verwenden.
5. Kann Transaktionen in gespeicherten Prozeduren verwenden.
6. Kann sowohl Tabellenvariablen als auch temporäre Tabellen verwenden.
7. Gespeicherte Prozeduren können Funktionen aufrufen.
8. Prozeduren können nicht über Select / Where / Have-Anweisungen usw. aufgerufen werden. Die Execute / Exec-Anweisung kann zum Aufrufen / Ausführen einer gespeicherten Prozedur verwendet werden.
9. Prozeduren können nicht in der Join-Klausel verwendet werden

Um zu entscheiden, wann die folgenden Punkte verwendet werden sollen:

1. Gespeicherte Prozeduren können keine Tabellenvariable zurückgeben, wenn dies als Funktion möglich ist.

2. Sie können gespeicherte Prozeduren verwenden, um die Serverumgebungsparameter zu ändern, wenn Sie keine Funktionen verwenden können.

Prost

SQL Server-Funktionen wie Cursor sollen als letzte Waffe verwendet werden! Sie haben Leistungsprobleme und daher sollte die Verwendung einer Tabellenwertfunktion so weit wie möglich vermieden werden. Wenn Sie von Leistung sprechen, sprechen Sie von einer Tabelle mit mehr als 1.000.000 Datensätzen, die auf einem Server auf einer Hardware der Mittelklasse gehostet werden. Andernfalls müssen Sie sich keine Gedanken über die durch die Funktionen verursachten Leistungseinbußen machen.

1. Verwenden Sie niemals eine Funktion, um eine Ergebnismenge an einen externen Code (wie ADO.Net) zurückzugeben.
2. Verwenden Sie so oft wie möglich die Kombination aus Ansichten und gespeicherten Prozessen. Mit den Vorschlägen, die DTA (Database Tuning Adviser) Ihnen (wie indizierte Ansichten und Statistiken) unterbreitet, können Sie sich von zukünftigen Problemen mit der Wachstumsleistung erholen - manchmal!

Weitere Informationen finden Sie unter: http://databases.aspfaq.com/database/should-i-use-a-view-a-stored-procedure-or-a-user-defined-function.html

Beginnen Sie mit Funktionen, die einen einzelnen Wert zurückgeben. Das Schöne ist, dass Sie häufig verwendeten Code in eine Funktion einfügen und als Spalte in einer Ergebnismenge zurückgeben können.

Anschließend können Sie eine Funktion für eine parametrisierte Liste von Städten verwenden. dbo.GetCitiesIn ("NY") Gibt eine Tabelle zurück, die als Join verwendet werden kann.

Es ist eine Möglichkeit, Code zu organisieren. Zu wissen, wann etwas wiederverwendbar ist und wann es Zeitverschwendung ist, wird nur durch Versuch und Irrtum und Erfahrung gewonnen.

Auch Funktionen sind in SQL Server eine gute Idee. Sie sind schneller und können sehr mächtig sein. Inline- und Direktauswahl. Achten Sie darauf, nicht zu viel zu verwenden.

Hier ist ein praktischer Grund, Funktionen gespeicherten Prozeduren vorzuziehen. Wenn Sie eine gespeicherte Prozedur haben, die die Ergebnisse einer anderen gespeicherten Prozedur benötigt, müssen Sie eine insert-exec-Anweisung verwenden. Dies bedeutet, dass Sie eine temporäre Tabelle erstellen und eine execAnweisung verwenden müssen, um die Ergebnisse der gespeicherten Prozedur in die temporäre Tabelle einzufügen. Es ist unordentlich. Ein Problem dabei ist, dass Insert-Execs nicht verschachtelt werden können .

Wenn Sie mit gespeicherten Prozeduren nicht weiterkommen, die andere gespeicherte Prozeduren aufrufen, können Sie darauf stoßen. Wenn die verschachtelte gespeicherte Prozedur einfach ein Dataset zurückgibt, kann es durch eine Tabellenwertfunktion ersetzt werden, und dieser Fehler wird nicht mehr angezeigt.

( Dies ist ein weiterer Grund, warum wir die Geschäftslogik aus der Datenbank heraushalten sollten. )

• Für Function ist es obligatorisch, einen Wert zurückzugeben, während dies nicht für gespeicherte Prozeduren gilt.
• Wählen Sie Anweisungen aus, die nur in UDF akzeptiert werden, während DML-Anweisungen nicht erforderlich sind.
• Die gespeicherte Prozedur akzeptiert sowohl Anweisungen als auch DML-Anweisungen.
• UDF erlaubt nur Ein- und keine Ausgänge.
• Die gespeicherte Prozedur ermöglicht sowohl Ein- als auch Ausgänge.
• Catch-Blöcke können nicht in UDF verwendet werden, sondern können in gespeicherten Prozeduren verwendet werden.
• In Funktionen in UDF sind keine Transaktionen zulässig, in gespeicherten Prozeduren jedoch.
• In UDF können nur Tabellenvariablen verwendet werden, keine temporären Tabellen.
• Die gespeicherte Prozedur ermöglicht sowohl Tabellenvariablen als auch temporäre Tabellen.
• UDF erlaubt nicht, dass gespeicherte Prozeduren von Funktionen aufgerufen werden, während gespeicherte Prozeduren das Aufrufen von Funktionen ermöglichen.
• UDF wird in der Join-Klausel verwendet, während gespeicherte Prozeduren in der Join-Klausel nicht verwendet werden können.
• Die gespeicherte Prozedur ermöglicht immer die Rückkehr zu Null. UDF hingegen hat Werte, die auf einen vorgegebenen Punkt zurückkommen müssen.

• Funktionen können in einer select-Anweisung verwendet werden, wenn Prozeduren dies nicht können.

• Die gespeicherte Prozedur akzeptiert sowohl Eingabe- als auch Ausgabeparameter, aber Funktionen akzeptiert nur Eingabeparameter.

• Funktionen können keine Werte vom Typ Text, ntext, Bild und Zeitstempel zurückgeben, sofern dies möglich ist.

• Funktionen können als benutzerdefinierte Datentypen in der Erstellungstabelle verwendet werden, Prozeduren jedoch nicht.

*** ZB: -erstellen table <tablename>(name varchar(10),salary getsal(name))

Hier ist getal eine benutzerdefinierte Funktion, die einen Gehaltstyp zurückgibt. Wenn eine Tabelle erstellt wird, wird kein Speicher für den Gehaltstyp zugewiesen, und die Funktion getsal wird ebenfalls nicht ausgeführt. Wenn wir jedoch einige Werte aus dieser Tabelle abrufen, werden die Funktion getal ausgeführt und die return Type wird als Ergebnismenge zurückgegeben.

Mir ist klar, dass dies eine sehr alte Frage ist, aber ich sehe in keiner der Antworten einen entscheidenden Aspekt: ​​Einfügen in den Abfrageplan.

Funktionen können sein ...

1. Skalar:

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

2. Tabellenwert mit mehreren Anweisungen:

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

3. Inline-Tabellenwert:

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

Die dritte Art (Inline-Tabellenwert) wird vom Abfrageoptimierer im Wesentlichen als (parametrisierte) Ansichten behandelt. Dies bedeutet, dass das Verweisen auf die Funktion aus Ihrer Abfrage dem Kopieren und Einfügen des SQL-Körpers der Funktion (ohne tatsächliches Kopieren) ähnlich ist zu folgenden Vorteilen:

• Der Abfrageplaner kann die Ausführung der Inline-Funktion wie jede andere Unterabfrage optimieren (z. B. nicht verwendete Spalten entfernen, Prädikate nach unten drücken, verschiedene JOIN-Strategien auswählen usw.).
• Das Kombinieren mehrerer Inline-Funktionen erfordert nicht, dass das Ergebnis von der ersten bis zur nächsten eingegeben wird.

Dies kann zu potenziell erheblichen Leistungseinsparungen führen, insbesondere wenn mehrere Funktionsebenen kombiniert werden.

HINWEIS: Es sieht so aus, als würde SQL Server 2019 auch eine Form von Inlining für Skalarfunktionen einführen .

In SQL Server sind Funktionen und gespeicherte Prozeduren zwei verschiedene Arten von Entitäten.

Funktion: In der SQL Server-Datenbank werden die Funktionen verwendet, um einige Aktionen auszuführen, und die Aktion gibt sofort ein Ergebnis zurück. Es gibt zwei Arten von Funktionen:

1. System definiert

2. Benutzerdefinierten

Gespeicherte Prozeduren: In SQL Server werden die gespeicherten Prozeduren auf dem Server gespeichert und können Null-, Einzel- und Mehrfachwerte zurückgeben. Es gibt zwei Arten von gespeicherten Prozeduren:

1. Systemgespeicherte Prozeduren
2. Benutzerdefinierte Verfahren