Am'am fost de învățare Funcții și Proceduri Stocate pentru un timp destul, dar nu't știu de ce și când ar trebui să utilizați o funcție sau o procedură stocată. Ei arata la fel pentru mine, poate pentru ca sunt cam newbie despre asta.
Poate unii o spune-mi de ce?
Funcțiile sunt valorile calculate și nu poate efectua permanent schimbările de mediu pentru SQL Server (de exemplu, nu INTRODUCE sau de a ACTUALIZA declarațiile permise).
O funcție poate fi utilizată inline în declarațiile SQL dacă se returnează o valoare scalară, sau pot fi unite printr dacă nu returnează un set de rezultate.
Un punct demn de remarcat de la comentarii, care rezuma răspunsul. Datorită @Sean K Anderson:
Funcții urmări computer-științific definiție în care acestea TREBUIE să se întoarcă o valoare și nu se pot modifica datele pe care le primesc ca parametri (argumentele). Funcțiile nu sunt permise pentru a schimba ceva, trebuie să au cel puțin un parametru, și ei trebuie să returneze o valoare. Stocate procs nu trebuie să aibă un parametru, se poate schimba obiectele bazei de date, și nu trebuie să returneze o valoare.
Diferența dintre SP și UDF este listat mai jos:
+---------------------------------+----------------------------------------+
| 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. | |
+---------------------------------+----------------------------------------+
Funcții și proceduri stocate servi scopuri separate. Deși l'nu e cea mai bună analogie, funcțiile pot fi vizualizate literalmente ca orice altă funcție tine'd folosi în orice limbaj de programare, dar stocate proc sunt mai mult ca programe individuale sau un script lot.
Funcțiile în mod normal, au o putere și, opțional intrări. De ieșire poate fi apoi folosit ca intrare pentru o altă funcție (un SQL Server built-in, cum ar fi DATEDIFF, LEN, etc) sau ca un predicat la o Interogare SQL - de exemplu, SELECT a, b, dbo.MyFunction(c) DE masă " sau " SELECT a, b, c DE la masa, UNDE un = dbo.MyFunc(c)
.
Stocate proc sunt folosite pentru a lega interogări SQL împreună într-o tranzacție, și interfața cu lumea exterioară. Cadrele, cum ar fi ADO.NET, etc. poate't apela o funcție direct, dar se poate apela un stocate proc direct.
Funcțiile nu au un pericol ascuns dacă: acestea pot fi utilizate în mod abuziv și că mai degrabă urât probleme de performanță: ia în considerare această interogare:
SELECT * FROM dbo.MyTable WHERE col1 = dbo.MyFunction(col2)
În cazul în care MyFunction este declarat ca:
CREATE FUNCTION MyFunction (@someValue INTEGER) RETURNS INTEGER
AS
BEGIN
DECLARE @retval INTEGER
SELECT localValue
FROM dbo.localToNationalMapTable
WHERE nationalValue = @someValue
RETURN @retval
END
Ce se întâmplă aici este că funcția MyFunction este numit pentru fiecare rând din tabel MyTable. Dacă MyTable a 1000 de rânduri, atunci's încă 1000 de interogări ad-hoc în baza de date. În mod similar, dacă funcția este apelată atunci când se specifică în coloana spec, atunci funcția va fi apelată pentru fiecare rand returnat de a SELECTA.
Deci, aveți nevoie pentru a fi atent la scrierea funcții. Dacă nu SELECTAȚI dintr-un tabel într-o funcție, trebuie să te întrebi dacă acesta poate fi mai bine realizat cu un ALĂTURAȚI-vă în părinte stocate proc sau alte SQL construct (cum ar fi CAZUL când ... CÂND ... ELSE ... END).
Diferențele între proceduri stocate și funcții definite de utilizator:
RAISEERROR " SAU " @@de EROARE
nu sunt permise în UDFs.GETDATE()
nu poate fi utilizat în UDFs.Scrie o funcție definită de utilizator atunci când doriți pentru a calcula și întoarce o valoare pentru utilizare în alte declarații SQL; scrie o procedură stocată atunci când doriți, în schimb, este de a grupa un eventual set complex de instrucțiuni SQL. Acestea sunt două destul de diferite cazuri de utilizare, după toate!
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.
De Bază Diferența
Funcția trebuie să returneze o valoare, dar, în Procedură Stocată este opțional( Procedura poate returna zero sau n valori).
Funcțiile pot avea numai parametri de intrare pentru acesta întrucât Procedurile pot fi de intrare/ieșire parametrii .
Funcția are un singur parametru de intrare este obligatorie, dar Procedură Stocată poate lua o a n parametri de intrare..
Funcțiile pot fi apelate din Procedura întrucât Procedurile nu poate fi numit din Funcție.
Avans, Diferență
Procedură vă permite să SELECTAȚI precum și DML(INSERT/UPDATE/DELETE) declarația în ea, întrucât Funcție vă permite să SELECTAȚI doar declarație în ea.
Procedurile nu pot fi utilizate într-o declarație SELECT întrucât Funcția poate fi încorporat într-o instrucțiune SELECT.
Procedurile stocate nu pot fi utilizate în instrucțiuni SQL oriunde în UNDE/AU/SELECTAȚI secțiunea întrucât Funcția poate fi.
Funcții care returnează tabele pot fi tratate ca un alt rowset. Acest lucru poate fi folosit în Unește cu alte tabele.
Funcție Inline poate fi totuși din vedere că avea parametri și pot fi utilizate în Alătură și alte Rowset operațiuni.
Excepție pot fi manipulate de try-catch bloc într-o Procedură întrucât try-catch bloc nu poate fi folosit într-o Funcție.
Putem merge pentru Management de Tranzacții în Procedură întrucât putem't merge în Funcție.
o Funcție Definită de Utilizator este un important instrument disponibil la un server sql programator. Puteți folosi inline într-o declarație SQL ca asa
SELECT a, lookupValue(b), c FROM customers
unde lookupValue` va fi un UDF. Acest tip de funcționalitate nu este posibil atunci când se utilizează o procedură stocată. În același timp, nu poți să faci anumite lucruri în interiorul unui UDF. Bază de lucru de reținut aici este că UDF's:
o procedură stocată poate face aceste lucruri.
Pentru mine inline utilizarea unui UDF este cel mai important de utilizare a unui UDF.
Proceduri stocate sunt utilizate ca script-uri. Ei rula serie de comenzi pentru tine și vă puteți programa pentru a rula în anumite momente.
Funcții sunt utilizate ca metode. Vei trece ceva și returnează un rezultat. Ar trebui să fie mici și rapid - se pe zbor.
Proceduri stocate:
Funcția:
SELECTAȚI dbo.functionname('Parametrul1')
sau
SELECTAȚI Nume, dbo.Functionname('Parametrul1') DIN sysObjects
SQL Server-funcții, cum ar fi cursoare, sunt destinate a fi utilizate ca ultima arma! Ei nu au probleme de performanță și, prin urmare, folosind un tabel evaluate funcția ar trebui să fie evitate pe cât posibil. Vorbim despre performanță este vorba de un tabel cu mai mult de 1.000.000 de înregistrări găzduit pe un server pe o clasa de mijloc hardware; în caz contrar, nu't nevoie să vă faceți griji despre hit de performanță cauzate de funcții.
pentru informații suplimentare, consultați: http://databases.aspfaq.com/database/should-i-use-a-view-a-stored-procedure-or-a-user-defined-function.html
Să decidă cu privire la momentul de a folosi ceea ce următoarele puncte ar putea ajuta
Procedurile stocate pot't se întoarcă o masă variabilă ca în cazul în care funcția poate face asta.
Puteți utiliza proceduri stocate pentru a modifica mediu de server parametri ca în cazul în care se utilizează funcții, puteți't.
noroc
Începe cu funcții care returnează o singură valoare. Cel mai frumos lucru este puteți pune în mod frecvent folosit de cod într-o funcție și să le returneze ca o coloană într-un set de rezultate.
Apoi, s-ar putea folosi o funcție pentru un parametrizate lista de orașe. dbo.GetCitiesIn("new YORK"), Care returnează un tabel care poate fi folosit ca o se alăture.
L's o modalitate de organizare a codului. Știind că atunci când ceva este reutilizabil și atunci când este o pierdere de timp este ceva de câștigat doar prin încercare și eroare și de experiență.
De asemenea, funcțiile sunt o idee bună în SQL Server. Ele sunt mai rapide și pot fi destul de puternice. În linie directă și selectează. Atenți să nu abuzăm.
Aici's un motiv practic pentru a prefera funcții în proceduri stocate. Dacă aveți o procedură stocată care are nevoie de rezultatele de o altă procedură stocată, trebuie să utilizați un insert-exec declarație. Acest lucru înseamnă că va trebui să creați un tabel temp și de a folosi un "exec" declarație pentru a introduce rezultatele proceduri stocate în tabel temp. L's murdar. O problemă cu acest lucru este că insert-directori nu pot fi imbricate.
Daca're blocat cu proceduri stocate care apela alte proceduri stocate, aveți dreptul să executați în acest sens. Dacă imbricate procedură stocată se întoarce pur și simplu un set de date, acesta poate fi înlocuit cu o masă evaluate funcția și te'll nu mai primesc eroarea asta.
(acesta este încă un motiv pentru care ar trebui să păstreze logica de afaceri din baza de date)
Funcții Definite De Utilizator.
Proceduri Stocate
Funcții pot fi utilizate într-o declarație select unde ca procedurile nu pot.
Stocate procedură durează atât de intrare și parametrii de ieșire, dar Funcțiile nevoie doar de parametrii de intrare.
Funcțiile nu pot returna valori de tip text, ntext, imagini & marcaje de timp în care ca procedurile pot.
Funcții pot fi utilizate ca definit de utilizator tipuri de date în tabelul crea, dar procedurile nu pot.
***De exemplu:-a crea masa <nume tabelă>(nume varchar(10),salariu getsal(nume))`
Aici getsal este o funcție definită de utilizator care returnează un salariu tip, atunci când tabelul este creat nu de stocare este alocat pentru salariu tip, și getsal funcție este, de asemenea, nu a executat, Dar atunci când suntem preluarea unor valorile din acest tabel, getsal funcția ia s-a executat și a reveni Tip sunt returnate în setul de rezultate.
Îmi dau seama că este o întrebare foarte veche, dar nu't vedea un aspect important menționat în oricare dintre răspunsurile: inlining în plan de interogare.
Funcțiile pot fi...
Pentru a CREA o FUNCȚIE RETURNEAZĂ scalar_type CA BEGIN ... END`
Pentru a CREA o FUNCȚIE RETURNEAZĂ @r de MASĂ(...) CUM BEGIN ... END`
PENTRU A CREA O FUNCȚIE RETURNEAZĂ MASA CA ÎNTOARCERE A SELECTA ...`
Al treilea tip (tabel inline-evaluate) sunt tratate de optimizare interogare, în esență, ca (parametrizat) vizualizări, ceea ce înseamnă că corelarea funcția de interogare este similar cu copie-lipirea funcția's SQL corpului (de fapt, fără copiere-lipire), ceea ce duce la următoarele beneficii:
Cele de mai sus poate duce la un potențial semnificativ de performanță de economii, mai ales atunci când se combină mai multe niveluri de funcții.
NOTĂ: se Pare ca SQL Server 2019 va introduce o formă de funcție scalară inlining la fel de bine.
În SQL Server, funcții și proceduri stocate sunt două tipuri de entități.
Funcție: În baza de date SQL Server, funcțiile sunt utilizate pentru a efectua unele acțiuni și măsuri returnează un rezultat imediat. Funcțiile sunt de două tipuri:
Sistem definit
Definite de utilizator
Proceduri stocate: În SQL Server, procedurile stocate sunt stocate pe server și pot fi reveni la zero, singur și mai multe valori. Procedurile stocate sunt de două tipuri: