SQL Server 2016:Skapa en lagrad procedur

En lagrad procedur är en grupp SQL-satser kompilerade till en. Lagrade procedurer kan inkludera affärslogik och andra programmeringskonstruktioner.

I SQL Server är en lagrad procedur en grupp av en eller flera Transact-SQL-satser eller en referens till en Microsoft .NET Framework common runtime language (CLR)-metod.

Programmerbarhet

Men en lagrad procedur är mer än bara ett långt manus. Det är ett skript som har sparats i SQL Server specifikt under Lagrade procedurer nod, och den kan:

• Acceptera indataparametrar (och returnera flera värden i form av utdataparametrar till det anropande programmet).
• Innehåller programmeringsförklaringar.
• Återställ ett statusvärde till ett anropsprogram för att indikera framgång eller misslyckande och orsaken till eventuella misslyckanden.

Lagrade procedurer innehåller ofta affärslogik. Till exempel kan en lagrad procedur acceptera parametrar som skickas till den och testa mot dessa parametrar med IF uttalanden. T.ex. om parametern är ett värde, gör detta, om det är ett annat värde, gör det.

Lagrade procedurer kan förbättra prestandan i en applikation, eftersom den lagrade proceduren analyseras och optimeras så snart den skapas och sedan lagras i minnet. Att köra en villkorlig förfrågan via lagrad procedur kan vara extremt snabbt - jämfört med en applikation som skickar en förfrågan över nätverket, till SQL-servern, och sedan får all data tillbaka till den över nätverket så att den kan filtrera igenom den och välja ut endast de skivor den är intresserad av.

Fördelar med lagrade procedurer

Här är några av de viktigaste fördelarna med att använda lagrade procedurer:

Hur man skapar en lagrad procedur

För att skapa en lagrad procedur, använd CREATE PROCEDURE uttalande, följt av koden som utgör den lagrade proceduren. Om din lagrade procedur ska acceptera parametrar måste de inkluderas efter namnet.

CREATE PROCEDURE myStoredProcedure AS
...

OR

CREATE PROCEDURE myStoredProcedure @ParameterName DataType AS
...

Vi kommer nu att skapa en lagrad procedur baserat på en av vyerna som vi skapade tidigare — Senaste albumen visa.

Denna vy visar alla album som släppts under de senaste 20 åren. Det här är bra så länge det bara behöver se tillbaka 20 år. Men vad händer om du vill att användaren ska välja hur många år den ska täcka?

En lagrad procedur kan lösa detta problem.

Vi kommer att skapa en lagrad procedur som accepterar en parameter. Värdet på parametern kommer att vara antalet år att söka tillbaka över. Därför kan detta värde anges av användaren närhelst de utför den lagrade proceduren.

1. Design den lagrade proceduren

   

   Öppna ett nytt frågefönster och lägg till koden för den lagrade proceduren.

   I vårt fall kommer vi att kopiera/klistra in koden från RecentArtists visa och ändra den övre delen så att den blir en lagrad procedur.

   Vi kommer att lägga till en parameter som heter @Count som kommer att avgöra hur många år den lagrade proceduren ska se tillbaka.

   Så vi kommer att ersätta det hårdkodade värdet för 20 med @Count

   Exempelkod

   Här är koden från vårt exempel:

   CREATE PROCEDURE spRecentAlbums @Count int
   AS
   SELECT  Albums.ReleaseDate, 
           Albums.AlbumName, 
           Genres.Genre, 
           Artists.ArtistName,
           Artists.ActiveFrom
   FROM Albums 
   INNER JOIN
           Artists ON 
           Albums.ArtistId = Artists.ArtistId 
           INNER JOIN
               Genres ON 
               Albums.GenreId = Genres.GenreId
   WHERE   (Albums.ReleaseDate > DATEADD(year, - @Count, GETDATE()));

2. Skapa den lagrade proceduren

   

   När allt ser bra ut kan du köra satsen för att skapa den lagrade proceduren.

   Klicka på Kör för att skapa den lagrade proceduren.

   När den lagrade proceduren har skapats kan du se den i objektutforskaren (du kan behöva uppdatera Lagrade procedurer noden först).

3. Utför den lagrade proceduren

   

   Nu när den har skapats kan du utföra den lagrade proceduren.

   Öppna ett nytt frågefönster, lägg till detta:

   EXEC spRecentAlbums @Count = 5;

   Klicka nu på Kör från verktygsfältet.

   Den lagrade proceduren kommer att returnera alla album som släppts under de senaste 5 åren.

4. Prova olika parametrar

   

   Försök att ändra värdet på parametern för att se hur detta påverkar resultaten.

   Du kan också köra flera satser efter varandra. En ny resultatruta visas för varje påstående.

Lagrad procedurmall

I SQL Server 2016 kan du skapa en lagrad procedur genom att högerklicka på Lagrade procedurer nod i objektutforskaren och välj Ny> Lagrad procedur... eller Ny> Inbyggt kompilerad lagrad procedur... .

Detta öppnar en mall som är redo att fyllas i med din egen specifika procedur.

Utför en lagrad procedur via GUI

Du kan också använda det grafiska användargränssnittet för att utföra en lagrad procedur.

1. Starta Execute Procedure Dialogrutan

   

   I objektutforskaren högerklickar du på den lagrade proceduren och väljer Execute Stored Procedure... .

2. Försörjningsparametrar

   

   Ange ett värde för alla parametrar som den lagrade proceduren kräver och klicka sedan på OK .

3. Resultaten

   

   Resultaten visas.

Ändra en lagrad procedur

Om du behöver ändra en befintlig lagrad procedur, ersätt bara CREATE med ALTER (tillsammans med den uppdaterade proceduren).

Det här exemplet ändrar den lagrade proceduren så att resultaten sorteras efter releasedatum i fallande ordning:

ALTER PROCEDURE spRecentAlbums @Count int
AS
SELECT  Albums.ReleaseDate, 
        Albums.AlbumName, 
        Genres.Genre, 
        Artists.ArtistName,
        Artists.ActiveFrom
FROM Albums 
INNER JOIN
        Artists ON 
        Albums.ArtistId = Artists.ArtistId 
        INNER JOIN
            Genres ON 
            Albums.GenreId = Genres.GenreId
WHERE   (Albums.ReleaseDate > DATEADD(year, - @Count, GETDATE()))
ORDER BY Albums.ReleaseDate DESC;

Systemlagrade procedurer

SQL Server innehåller ett stort antal systemlagrade procedurer för att underlätta databasadministration. Många av de uppgifter du kan utföra via det grafiska användargränssnittet kan göras via en systemlagrad procedur. Till exempel, några av de saker du kan göra med systemlagrade procedurer inkluderar:

• Konfigurera säkerhetskonton
• Konfigurera länkade servrar
• Skapa en databasunderhållsplan
• Skapa fulltextsökningskataloger
• Lägg till fjärrinloggning
• Konfigurera replikering
• Konfigurera schemalagda jobb
• och mycket mer...

Systemlagrade procedurer har prefixet sp__ , så det är bäst att undvika att använda det prefixet för dina egna procedurer.

Namnkonventioner

Det är en bra idé att utveckla en konsekvent namnkonvention för dina lagrade procedurer (och för alla andra objekt i din databas).

Vissa personer prefixer sina lagrade procedurer med usp_ (för att indikera en användardefinierad lagrad procedur), andra börjar den med ett SQL-nyckelord som select , infoga , uppdatering , ta bort . Andra använder en förkortning för applikationen.

Vissa använder understreck för att separera varje ord i den lagrade proceduren (t.ex. recent_albums ), medan andra använder skiftläge (t.ex. Senaste album ). ).

Därför är det möjligt att vår lagrade procedur kan döpas till något av följande, beroende på vilken namnkonvention som används.

• Senaste album
• recent_albums
• uspRecentAlbums
• usp_recent_albums
• välj Senaste album
• select_RecentAlbums
• select_recent_albums
• getRecentAlbums
• get_recent_albums

Du fattar bilden. Det viktiga är konsekvens. Välj en och håll dig till den. Det kommer att göra det lättare när du behöver använda en lagrad procedur. Föreställ dig att du har poäng, eller till och med hundratals lagrade procedurer, och varje gång du går för att köra en måste du navigera till den i Objektutforskaren enbart för att du inte kommer ihåg om du kallade den usp_RecentAlbums eller uspRecentAlbums .

Som nämnt, undvik att använda sp__ som prefix för dina lagrade procedurnamn. SQL Server använder detta prefix för de systemlagrade procedurerna.

SQL Server söker först igenom systemets lagrade procedurer, så i bästa fall får du en prestandaträff. I värsta fall kommer din procedur inte att köras (om den delar ett namn med en systemlagrad procedur).