it-swarm.com.de

Funktion gegen 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 genauso aus, vielleicht, weil ich ein bisschen Neuling darin bin.

Kann mir jemand sagen warum?

778
Tarik

Funktionen sind berechnete Werte und können keine permanenten Umgebungsänderungen an SQL Server vornehmen (d. H. Keine INSERT- oder UPDATE-Anweisungen zulässig).

Eine Funktion kann in SQL-Anweisungen inline verwendet werden, wenn sie einen skalaren Wert zurückgibt, oder sie kann verknüpft werden, wenn sie eine Ergebnismenge zurückgibt.

Ein bemerkenswerter Punkt aus Kommentaren, die die Antwort zusammenfassen. Danke an @Sean K Anderson:

Funktionen folgen der Definition der Informatik dahingehend, dass sie einen Wert zurückgeben MÜSSEN und die Daten, die sie als Parameter (die Argumente) erhalten, 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.

671
MyItchyChin

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.    |                                        |
+---------------------------------+----------------------------------------+
578
Bhaumik Patel

Funktionen und gespeicherte Prozeduren dienen unterschiedlichen 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, aber gespeicherte Prozeduren ähneln 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 (einen integrierten 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 table oder SELECT a, b, c FROM table WHERE a = dbo.MyFunc(c).

Gespeicherte Prozeduren 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, sie können jedoch 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)

Wobei 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 dies in der Spaltenspezifikation angegeben ist, wird die Funktion für jede Zeile aufgerufen, die von SELECT zurückgegeben wird.

Sie müssen also vorsichtig mit 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 proc oder einem anderen SQL-Konstrukt (wie CASE ... WHEN ... ELSE ...) besser durchgeführt werden kann. ENDE).

186
Chris J

Schreiben Sie eine benutzerdefinierte Funktion, wenn Sie einen Wert zur Verwendung in anderen SQL-Anweisungen berechnen und zurückgeben möchten. Wenn Sie stattdessen eine gespeicherte Prozedur schreiben möchten, müssen Sie eine möglicherweise komplexe Gruppe von SQL-Anweisungen gruppieren. Das sind schließlich zwei ziemlich unterschiedliche Anwendungsfälle!

56
Alex Martelli

Unterschiede zwischen gespeicherten Prozeduren und benutzerdefinierten Funktionen:

  • Gespeicherte Prozeduren können in Select-Anweisungen nicht verwendet werden.
  • Gespeicherte Prozeduren unterstützen die verzögerte Namensauflösung.
  • Gespeicherte Prozeduren werden im Allgemeinen zum Ausführen von Geschäftslogik verwendet.
  • Gespeicherte Prozeduren können jeden Datentyp zurückgeben.
  • Gespeicherte Prozeduren akzeptieren möglicherweise mehr Eingabeparameter 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 keine verzögerte Namensauflösung.
  • 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 die Fehlerbehandlung nicht. RAISEERROR OR @@ERROR sind in UDFs nicht zulässig.
  • Nicht deterministische Funktionen können in UDFs nicht verwendet werden. Beispielsweise kann GETDATE() nicht in UDFs verwendet werden.
56
              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.
32
Aakash Singh

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, wohingegen Prozeduren Eingabe-/Ausgabeparameter haben können.

Die Funktion akzeptiert einen Eingabeparameter, der obligatorisch ist, aber die gespeicherte Prozedur kann o bis n Eingabeparameter annehmen.

Funktionen können von der Prozedur aus aufgerufen werden, wohingegen Prozeduren nicht von der Funktion aus aufgerufen werden können.

Vorlaufdifferenz

In der Prozedur ist die Anweisung SELECT sowie die Anweisung DML (INSERT/UPDATE/DELETE) zulässig, während in der Anweisung Function nur die Anweisung SELECT zulässig ist.

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

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

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

Die Inline-Funktion kann als Ansichten definiert werden, die Parameter annehmen und in JOINs und anderen Rowset-Vorgängen verwendet werden können.

Eine Ausnahme kann durch den try-catch-Block in einer Prozedur behandelt werden, wohingegen der try-catch-Block in einer Funktion nicht verwendet werden kann.

Wir können uns für das Transaktionsmanagement in der Prozedur entscheiden, wohingegen wir uns nicht für die Funktion entscheiden können.

Quelle

22
Ankit

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

SELECT a, lookupValue(b), c FROM customers 

dabei ist lookupValue eine UDF. Diese Art von Funktionalität ist bei Verwendung einer gespeicherten Prozedur nicht möglich. Gleichzeitig können Sie in einer UDF bestimmte Dinge nicht ausführen. Das Grundlegende, woran Sie sich erinnern sollten, 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-Nutzung einer UDF die wichtigste Nutzung einer UDF.

19
OpenSource

Stored Procedures 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.

Funktionen werden als Methoden verwendet. Sie übergeben etwas und es wird ein Ergebnis zurückgegeben. Sollte klein und schnell sein - schnell erledigt.

13
Tigerjz32

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 der Anweisung EXEC oder EXECUTE aufgerufen werden.
  • Gibt Tabellenvariablen zurück, aber wir können den Parameter OUT nicht 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 zum Auswählen von Datensätzen verwendet werden. Es kann jedoch sehr einfach aus Standard-SQL heraus aufgerufen werden, wie zum Beispiel:

    SELECT dbo.functionname('Parameter1')
    

    oder

    SELECT Name, dbo.Functionname('Parameter1') FROM sysObjects
    
  • Für einfache wiederverwendbare Auswahloperationen können Funktionen den Code vereinfachen. Seien Sie vorsichtig, wenn Sie JOIN -Klauseln in Ihren Funktionen verwenden. Wenn Ihre Funktion eine JOIN -Klausel hat und Sie diese von einer anderen select-Anweisung aufrufen, die mehrere Ergebnisse zurückgibt, werden diese Tabellen für die im Ergebnis zurückgegebenen jeweils -Zeilen durch diesen Funktionsaufruf JOIN zusammengeführt einstellen. Obwohl sie bei der Vereinfachung von Logik hilfreich sein können, können sie auch einen Leistungsengpass darstellen, wenn sie nicht ordnungsgemäß verwendet werden.

  • Gibt die Werte mit dem Parameter OUT zurück.
  • Unterstützt keine Transaktionen.
8
JaiSankarN

SQL Server-Funktionen, wie Cursor, sollen als Ihre letzte Waffe verwendet werden! Sie haben Leistungsprobleme und daher sollte die Verwendung einer Tabellenwertfunktion so weit wie möglich vermieden werden. Unter Leistung versteht man eine Tabelle mit mehr als 1.000.000 Datensätzen, die auf einem Server auf einer Hardware der Mittelklasse gehostet werden. Ansonsten müssen Sie sich keine Gedanken über die Leistung machen, die durch die Funktionen verursacht wird.

  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. Sie können sich von zukünftigen Wachstumsleistungsproblemen erholen, indem Sie die Vorschläge verwenden, die DTA (Database Tuning Adviser) Ihnen geben würde (wie indizierte Ansichten und Statistiken) - 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 =

6
Achilles

Um zu entscheiden, wann verwendet werden soll, können die folgenden Punkte hilfreich sein:

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

  2. Sie können gespeicherte Prozeduren verwenden, um die Parameter der Serverumgebung zu ändern, wenn Sie Funktionen verwenden, die Sie nicht können.

prost

6
Arnkrishn

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

Dann 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 Art, Code zu organisieren. Zu wissen, wann etwas wiederverwendbar ist und wann es Zeitverschwendung ist, wird nur durch Versuch und Irrtum und Erfahrung erlangt.

Außerdem sind Funktionen in SQL Server eine gute Idee. Sie sind schneller und können sehr leistungsfähig sein. Inline- und Direktauswahl. Seien Sie vorsichtig, um nicht zu überbeanspruchen.

3
Andrew
  • 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.
  • Gespeicherte Prozeduren akzeptieren alle Anweisungen sowie DML-Anweisungen.
  • UDF erlaubt nur Eingaben und keine Ausgaben.
  • Gespeicherte Prozeduren ermöglichen sowohl Ein- als auch Ausgänge.
  • Catch-Blöcke können nicht in UDF, sondern in Stored Procedure verwendet werden.
  • In Funktionen in UDF sind keine Transaktionen zulässig, in gespeicherten Prozeduren sind sie jedoch zulässig.
  • In UDF können nur Tabellenvariablen und keine temporären Tabellen verwendet werden.
  • Gespeicherte Prozeduren ermöglichen sowohl Tabellenvariablen als auch temporäre Tabellen.
  • In UDF können gespeicherte Prozeduren nicht 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 zu einem vorbestimmten Punkt zurückkehren müssen.
2
kombsh

Hier ist ein praktischer Grund, Funktionen gegenüber 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 exec -Anweisung 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 können nicht verschachtelt werden .

Wenn Sie mit gespeicherten Prozeduren, die andere gespeicherte Prozeduren aufrufen, nicht weiterkommen, können Sie diese ausführen. Wenn die verschachtelte gespeicherte Prozedur einfach ein Dataset zurückgibt, kann es durch eine Tabellenwertfunktion ersetzt werden, und dieser Fehler tritt nicht mehr auf.

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

2
user2023861
  • Funktionen können in einer select-Anweisung verwendet werden, was mit Prozeduren nicht möglich ist.

  • Gespeicherte Prozeduren akzeptieren sowohl Eingabe- als auch Ausgabeparameter, aber Funktionen akzeptieren nur Eingabeparameter.

  • Funktionen können keine Werte vom Typ text, ntext, image & timestamps zurückgeben, wo dies durch Prozeduren möglich ist.

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

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

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

1
Nick Kahn

Mir ist klar, dass dies eine sehr alte Frage ist, aber ich sehe in keiner der Antworten einen entscheidenden Aspekt: ​​das 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 Referenzieren der Funktion aus Ihrer Abfrage dem Kopieren und Einfügen des SQL-Texts der Funktion (ohne tatsächliches Kopieren und Einfügen) entspricht 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, andere JOIN-Strategien auswählen usw.).
  • Wenn Sie mehrere Inline-Funktionen kombinieren, müssen Sie das Ergebnis nicht erst aus dem ersten zusammensetzen, bevor Sie es dem nächsten zuführen.

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


HINWEIS: SQL Server 2019 wird anscheinend auch eine Form von Skalarfunktions-Inlining einführen.

1

Benutzerdefinierte Funktion.

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

gespeicherte Prozedur

  1. Gespeicherte Prozedur kann Werte zurückgeben oder nicht.
  2. Kann sowohl SELECT-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 innerhalb von Stored Procedures 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/Having-Anweisungen usw. aufgerufen werden. Die Execute/Exec-Anweisung kann zum Aufrufen/Ausführen einer gespeicherten Prozedur verwendet werden.
  9. Prozeduren können in der Join-Klausel nicht verwendet werden
0
Mahesh Waghmare