SKAPA PROCEDUR (Transact-SQL)

Gäller för:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsAnalysplattformssystem (PDW)SQL-analysslutpunkt i Microsoft FabricLager i Microsoft FabricSQL-databas i Förhandsversion av Microsoft Fabric

Skapar en Transact-SQL eller en CLR-lagrad procedur (Common Language Runtime) i SQL Server, Azure SQL Database, SQL Database i Microsoft Fabric Preview och Analytics Platform System (PDW). Lagrade procedurer liknar procedurer i andra programmeringsspråk på så sätt att de kan:

• Acceptera indataparametrar och returnera flera värden i form av utdataparametrar till anropsproceduren eller batchen.
• Innehåller programmeringsinstruktioner som utför åtgärder i databasen, inklusive att anropa andra procedurer.
• Returnera ett statusvärde till en anropande procedur eller batch för att ange lyckade eller misslyckade (och orsaken till felet).

Använd den här instruktionen tempdb för att skapa en permanent procedur i den aktuella databasen eller en tillfällig procedur i databasen.

Hoppa till Enkla exempel för att hoppa över information om syntaxen och få ett snabbt exempel på en grundläggande lagrad procedur.

Transact-SQL syntaxkonventioner

Syntax

Transact-SQL syntax för lagrade procedurer i SQL Server, Azure SQL Database, SQL Database i Förhandsversion av Microsoft Fabric:

CREATE [ OR ALTER ] { PROC | PROCEDURE }
    [schema_name.] procedure_name [ ; number ]
    [ { @parameter_name [ type_schema_name. ] data_type }
        [ VARYING ] [ NULL ] [ = default ] [ OUT | OUTPUT | [READONLY]
    ] [ ,...n ]
[ WITH <procedure_option> [ ,...n ] ]
[ FOR REPLICATION ]
AS { [ BEGIN ] sql_statement [;] [ ...n ] [ END ] }
[;]

<procedure_option> ::=
    [ ENCRYPTION ]
    [ RECOMPILE ]
    [ EXECUTE AS Clause ]

Transact-SQL syntax för CLR-lagrade procedurer:

CREATE [ OR ALTER ] { PROC | PROCEDURE }
    [schema_name.] procedure_name [ ; number ]
    [ { @parameter_name [ type_schema_name. ] data_type }
        [ = default ] [ OUT | OUTPUT ] [READONLY]
    ] [ ,...n ]
[ WITH EXECUTE AS Clause ]
AS { EXTERNAL NAME assembly_name.class_name.method_name }
[;]

Transact-SQL syntax för internt kompilerade lagrade procedurer:

CREATE [ OR ALTER ] { PROC | PROCEDURE } [schema_name.] procedure_name
    [ { @parameter data_type } [ NULL | NOT NULL ] [ = default ]
        [ OUT | OUTPUT ] [READONLY]
    ] [ ,... n ]
  WITH NATIVE_COMPILATION, SCHEMABINDING [ , EXECUTE AS clause ]
AS
{
  BEGIN ATOMIC WITH ( <set_option> [ ,... n ] )
sql_statement [;] [ ... n ]
[ END ]
}
[;]

<set_option> ::=
    LANGUAGE = [ N ] 'language'
  | TRANSACTION ISOLATION LEVEL = { SNAPSHOT | REPEATABLE READ | SERIALIZABLE }
  | [ DATEFIRST = number ]
  | [ DATEFORMAT = format ]
  | [ DELAYED_DURABILITY = { OFF | ON } ]

Transact-SQL syntax för lagrade procedurer i Azure Synapse Analytics och Parallel Data Warehouse:

CREATE { PROC | PROCEDURE } [ schema_name.] procedure_name
    [ { @parameter data_type } [ OUT | OUTPUT ] ] [ ,...n ]
AS
{
  [ BEGIN ] sql_statement [;][ ,...n ] [ END ]
}
[;]

Transact-SQL syntax för lagrade procedurer i Microsoft Fabric:

CREATE [ OR ALTER ] { PROC | PROCEDURE } [ schema_name.] procedure_name
    [ { @parameter data_type } [ OUT | OUTPUT ] ] [ ,...n ]
AS
{
  [ BEGIN ] sql_statement [;][ ,...n ] [ END ]
}
[;]

Arguments

ELLER ÄNDRA

Gäller för: Azure SQL Database, SQL Database i Microsoft Fabric Preview, SQL Server (från och med SQL Server 2016 (13.x) SP1).

Ändrar proceduren om den redan finns.

schema_name

Namnet på schemat som proceduren tillhör. Procedurerna är schemabundna. Om ett schemanamn inte anges när proceduren skapas tilldelas automatiskt standardschemat för den användare som skapar proceduren.

procedure_name

Namnet på proceduren. Procedurnamn måste följa reglerna för identifierare och måste vara unika i schemat.

Lokala eller globala tillfälliga procedurer kan skapas med hjälp av ett taltecken (#) innan procedure_name (#procedure_name) för lokala tillfälliga procedurer och två nummertecken för globala tillfälliga procedurer (##procedure_name). En lokal tillfällig procedur visas endast för anslutningen som skapade den och tas bort när anslutningen stängs. En global tillfällig procedur är tillgänglig för alla anslutningar och tas bort i slutet av den senaste sessionen med hjälp av proceduren. Det går inte att ange temporära namn för CLR-procedurer.

Det fullständiga namnet på en procedur eller en global tillfällig procedur, inklusive ##, får inte överstiga 128 tecken. Det fullständiga namnet på en lokal tillfällig procedur, inklusive #, får inte överstiga 116 tecken.

; nummer

Gäller för: SQL Server 2008 (10.0.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Ett valfritt heltal som används för att gruppera procedurer med samma namn. Dessa grupperade procedurer kan tas bort tillsammans med hjälp av en DROP PROCEDURE-instruktion.

Numrerade procedurer kan inte använda xml - eller CLR-användardefinierade typer och kan inte användas i en planguide.

@ parameter_name

En parameter som deklareras i proceduren. Ange ett parameternamn med hjälp av vid-tecknet (@) som det första tecknet. Parameternamnet måste följa reglerna för identifierare. Parametrarna är lokala för proceduren. samma parameternamn kan användas i andra procedurer.

En eller flera parametrar kan deklareras. maxvärdet är 2 100. Värdet för varje deklarerad parameter måste anges av användaren när proceduren anropas om inte ett standardvärde för parametern har definierats eller om värdet är inställt på lika med en annan parameter. Om en procedur innehåller tabellvärdesparametrar och parametern saknas i anropet skickas en tom tabell in. Parametrar kan bara ta plats för konstanta uttryck. De kan inte användas i stället för tabellnamn, kolumnnamn eller namn på andra databasobjekt. Mer information finns i EXECUTE (Transact-SQL).

Parametrar kan inte deklareras om FÖR REPLIKERing har angetts.

[ type_schema_name. ] data_type

Datatypen för parametern och schemat som datatypen tillhör.

Riktlinjer för Transact-SQL procedurer:

• Alla Transact-SQL datatyper kan användas som parametrar.
• Du kan använda den användardefinierade tabelltypen för att skapa tabellvärdesparametrar. Tabellvärdeparametrar kan bara vara indataparametrar och måste åtföljas av nyckelordet READONLY. Mer information finns i Använda Table-Valued parametrar (databasmotor)
• markördatatyper kan bara vara OUTPUT-parametrar och måste åtföljas av nyckelordet VARIERANDE.

Riktlinjer för CLR-procedurer:

• Alla inbyggda SQL Server-datatyper som har en motsvarighet i hanterad kod kan användas som parametrar. Mer information om korrespondensen mellan CLR-typer och SQL Server-systemdatatyper finns i Mappa CLR-parameterdata. Mer information om SQL Server-systemdatatyper och deras syntax finns i Datatyper (Transact-SQL).

• Tabellvärdes- eller markördatatyper kan inte användas som parametrar.

• Om datatypen för parametern är en CLR-användardefinierad typ måste du ha behörigheten EXECUTE för typen.

VARIERANDE

Anger den resultatuppsättning som stöds som en utdataparameter. Den här parametern skapas dynamiskt av proceduren och dess innehåll kan variera. Gäller endast för markörparametrar. Det här alternativet är inte giltigt för CLR-procedurer.

förvalt

Ett standardvärde för en parameter. Om ett standardvärde definieras för en parameter kan proceduren köras utan att ange ett värde för parametern. Standardvärdet måste vara en konstant eller så kan det vara NULL. Konstantvärdet kan vara i form av ett jokertecken, vilket gör det möjligt att använda nyckelordet LIKE när parametern skickas till proceduren.

Standardvärden registreras endast i sys.parameters.default kolumnen för CLR-procedurer. Kolumnen är NULL för Transact-SQL procedureparametrar.

UT | UTDATA

Anger att parametern är en utdataparameter. Använd OUTPUT-parametrar för att returnera värden till anroparen av proceduren. text-, ntext- och bildparametrar kan inte användas som OUTPUT-parametrar, såvida inte proceduren är en CLR-procedur. En utdataparameter kan vara en markörplatshållare, såvida inte proceduren är en CLR-procedur. En tabellvärdesdatatyp kan inte anges som en OUTPUT-parameter för en procedur.

READONLY

Anger att parametern inte kan uppdateras eller ändras i procedurens brödtext. Om parametertypen är en tabellvärdetyp måste READONLY anges.

RECOMPILE

Anger att databasmotorn inte cachelagras en frågeplan för den här proceduren, vilket tvingar den att kompileras varje gång den körs. Mer information om orsakerna till att tvinga en omkompilering finns i Kompilera om en lagrad procedur. Det här alternativet kan inte användas när FÖR REPLIKERing har angetts eller för CLR-procedurer.

Om du vill instruera databasmotorn att ignorera frågeplaner för enskilda frågor i en procedur använder du frågetipset RECOMPILE i definitionen av frågan. Mer information finns i Frågetips (Transact-SQL).

KRYPTERING

Gäller för: SQL Server 2008 (10.0.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Anger att SQL Server konverterar den ursprungliga texten i CREATE PROCEDURE-instruktionen till ett fördunkkat format. Utdata från fördunklingen visas inte direkt i någon av katalogvyerna i SQL Server. Användare som inte har åtkomst till systemtabeller eller databasfiler kan inte hämta den fördunklade texten. Texten är dock tillgänglig för privilegierade användare som antingen kan komma åt systemtabeller via DAC-porten eller direkt komma åt databasfiler. Användare som kan koppla ett felsökningsprogram till serverprocessen kan också hämta den dekrypterade proceduren från minnet vid körning. Mer information om åtkomst till systemmetadata finns i Konfiguration av metadatasynlighet.

Det här alternativet är inte giltigt för CLR-procedurer.

Procedurer som skapats med det här alternativet kan inte publiceras som en del av SQL Server-replikering.

EXECUTE AS-sats

Anger säkerhetskontexten under vilken proceduren ska köras.

För internt kompilerade lagrade procedurer finns det inga begränsningar för EXECUTE AS satsen. I SQL Server 2014 (12.x) och tidigare versioner stöds satserna SELF, OWNER, och "user_name" med inbyggda kompilerade lagrade procedurer.

Mer information finns i EXECUTE AS-satsen (Transact-SQL).

FÖR REPLIKERING

Gäller för: SQL Server 2008 (10.0.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Anger att proceduren skapas för replikering. Det går därför inte att köra den på prenumeranten. En procedur som skapas med alternativet FOR REPLICATION används som ett procedurfilter och körs endast under replikeringen. Parametrar kan inte deklareras om FÖR REPLIKERing har angetts. FÖR REPLIKERing kan inte anges för CLR-procedurer. Alternativet RECOMPILE ignoreras för procedurer som skapats med FOR REPLICATION.

En FOR REPLICATION procedur har en objekttyp RF i sys.objects och sys.procedures.

{ [ BEGIN ] sql_statement [;] [ ... n ] [ END ] }

En eller flera Transact-SQL uttalanden som består av förfarandets brödtext. Du kan använda de valfria nyckelorden BEGIN och END för att omsluta -uttrycken. Mer information finns i avsnitten Metodtips, Allmänna kommentarer och Begränsningar och Begränsningar som följer.

EXTERNT NAMN assembly_name. class_name. method_name

Gäller för: SQL Server 2008 (10.0.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Anger metoden för en .NET Framework-sammansättning för en CLR-procedur att referera till. class_name måste vara en giltig SQL Server-identifierare och måste finnas som en klass i sammansättningen. Om klassen har ett namnområdeskvalificerat namn som använder en punkt (.) för att separera namnområdesdelar måste klassnamnet avgränsas med hakparenteser ([]) eller citattecken (""). Den angivna metoden måste vara en statisk metod för klassen.

SQL Server kan som standard inte köra CLR-kod. Du kan skapa, ändra och släppa databasobjekt som refererar till vanliga språkkörningsmoduler. Du kan dock inte köra dessa referenser i SQL Server förrän du aktiverar det clr-aktiverade alternativet. Om du vill aktivera alternativet använder du sp_configure.

ATOMIC MED

Gäller för: SQL Server 2014 (12.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Anger körning av atomisk lagrad procedur. Ändringarna utförs antingen eller så återställs alla ändringar genom att ett undantag genereras. ATOMIC WITH-blocket krävs för internt kompilerade lagrade procedurer.

Om proceduren RETURN (explicit via RETURN-instruktionen eller implicit genom att slutföra körningen) utförs det arbete som utförs av proceduren. Om proceduren THROWs återställs det arbete som utförs av proceduren.

XACT_ABORT är PÅ som standard i ett atomiskt block och kan inte ändras. XACT_ABORT anger om SQL Server automatiskt återställer den aktuella transaktionen när en Transact-SQL-instruktion genererar ett körningsfel.

Följande SET-alternativ är alltid PÅ i ATOMIC-blocket och kan inte ändras.

• CONCAT_NULL_YIELDS_NULL
• QUOTED_IDENTIFIER, ARITHABORT
• NOCOUNT
• ANSI_NULLS
• ANSI_WARNINGS

SET-alternativ kan inte ändras i ATOMIC-block. SET-alternativen i användarsessionen används inte i omfånget för internt kompilerade lagrade procedurer. De här alternativen är fasta vid kompileringstillfället.

ÅTGÄRDERNA BEGIN, ROLLBACK och COMMIT kan inte användas i ett atomiskt block.

Det finns ett ATOMIC-block per inbyggt kompilerad lagrad procedur, i procedurens yttre omfång. Blocken kan inte kapslas. Mer information om atomiska block finns i Internt kompilerade lagrade procedurer.

NULL | INTE NULL

Avgör om null-värden tillåts i en parameter. NULL är standardvärdet.

NATIVE_COMPILATION

Gäller för: SQL Server 2014 (12.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Anger att proceduren är internt kompilerad. NATIVE_COMPILATION, SCHEMABINDING och EXECUTE AS kan anges i valfri ordning. Mer information finns i Internt kompilerade lagrade procedurer.

SCHEMABINDNING

Gäller för: SQL Server 2014 (12.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Ser till att tabeller som refereras till av en procedur inte kan tas bort eller ändras. SCHEMABINDING krävs i inbyggda kompilerade lagrade procedurer. (Mer information finns i Internt kompilerade lagrade procedurer.) SCHEMABINDING-begränsningarna är desamma som för användardefinierade funktioner. Mer information finns i avsnittet SCHEMABINDING i CREATE FUNCTION (Transact-SQL).

LANGUAGE = [N] 'language'

Gäller för: SQL Server 2014 (12.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Motsvarar sessionsalternativet SET LANGUAGE (Transact-SQL). LANGUAGE = [N] "language" krävs.

TRANSAKTIONSISOLERINGSNIVÅ

Gäller för: SQL Server 2014 (12.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Krävs för internt kompilerade lagrade procedurer. Anger transaktionsisoleringsnivån för den lagrade proceduren. Alternativen är följande:

Mer information om dessa alternativ finns i ANGE TRANSAKTIONSISOLERINGSNIVÅ (Transact-SQL).

REPETERBAR LÄSNING

Anger att instruktioner inte kan läsa data som har ändrats men som ännu inte har bekräftats av andra transaktioner. Om en annan transaktion ändrar data som har lästs av den aktuella transaktionen misslyckas den aktuella transaktionen.

SERIALISERAS

Anger följande:

• Instruktioner kan inte läsa data som har ändrats men som ännu inte har checkats in av andra transaktioner.
• Om en annan transaktion ändrar data som har lästs av den aktuella transaktionen misslyckas den aktuella transaktionen.
• Om en annan transaktion infogar nya rader med nyckelvärden som skulle falla i intervallet med nycklar som läss av några instruktioner i den aktuella transaktionen misslyckas den aktuella transaktionen.

ÖGONBLICKSBILD

Anger att data som läse av en instruktion i en transaktion är den transaktionsmässigt konsekventa versionen av de data som fanns i början av transaktionen.

DATEFIRST = tal

Gäller för: SQL Server 2014 (12.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Anger den första dagen i veckan till ett tal mellan 1 och 7. DATEFIRST är valfritt. Om den inte anges härleds inställningen från det angivna språket.

Mer information finns i ANGE DATEFIRST (Transact-SQL).

DATEFORMAT = format

Gäller för: SQL Server 2014 (12.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

Anger ordningen på datumdelarna månad, dag och år för tolkning av teckensträngarna date, smalldatetime, datetime, datetime2 och datetimeoffset . DATEFORMAT är valfritt. Om den inte anges härleds inställningen från det angivna språket.

Mer information finns i ANGE DATEFORMAT (Transact-SQL).

DELAYED_DURABILITY = { OFF | PÅ }

Gäller för: SQL Server 2014 (12.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

SQL Server-transaktionsincheckningar kan antingen vara helt varaktiga, standardvärdet eller fördröjda varaktiga.

Mer information finns i Kontrollera transaktionshållbarhet.

Enkla exempel

Här är två snabba exempel som hjälper dig att komma igång: SELECT DB_NAME() AS ThisDB; returnerar namnet på den aktuella databasen. Du kan omsluta instruktionen i en lagrad procedur, till exempel:

CREATE PROC What_DB_is_this
AS
SELECT DB_NAME() AS ThisDB;

Anropa butiksproceduren med -instruktionen: EXEC What_DB_is_this;

Något mer komplext är att tillhandahålla en indataparameter för att göra proceduren mer flexibel. Till exempel:

CREATE PROC What_DB_is_that @ID INT
AS
SELECT DB_NAME(@ID) AS ThatDB;

Ange ett databas-ID-nummer när du anropar proceduren. Till exempel returnerar EXEC What_DB_is_that 2;tempdb.

Se Exempel mot slutet av den här artikeln för många fler exempel.

Metodtips

Även om detta inte är en fullständig lista över metodtips kan dessa förslag förbättra procedurens prestanda.

• Använd SET NOCOUNT ON-instruktionen som den första instruktionen i procedurens brödtext. Det vill: placera den strax efter AS-nyckelordet. Detta inaktiverar meddelanden som SQL Server skickar tillbaka till klienten när några SELECT-, INSERT-, UPDATE-, MERGE- och DELETE-instruktioner har körts. Detta håller utdata som genereras till ett minimum för tydlighetens skull. Det finns dock ingen mätbar prestandafördel på dagens maskinvara. Mer information finns i SET NOCOUNT (Transact-SQL).
• Använd schemanamn när du skapar eller refererar till databasobjekt i proceduren. Det tar mindre bearbetningstid för databasmotorn att matcha objektnamn om den inte behöver söka i flera scheman. Det förhindrar också behörighets- och åtkomstproblem som orsakas av att en användares standardschema tilldelas när objekt skapas utan att ange schemat.
• Undvik att omsluta funktioner runt kolumner som anges i WHERE- och JOIN-satserna. Detta gör kolumnerna icke-deterministiska och hindrar frågeprocessorn från att använda index.
• Undvik att använda skalärfunktioner i SELECT-instruktioner som returnerar många rader med data. Eftersom den skalära funktionen måste tillämpas på varje rad är det resulterande beteendet som radbaserad bearbetning och försämrar prestanda.
• Undvik att använda SELECT *. Ange i stället de obligatoriska kolumnnamnen. Detta kan förhindra vissa databasmotorfel som stoppar procedurkörningen. En instruktion som till exempel SELECT * returnerar data från en 12-kolumntabell och sedan infogar dessa data i en temporär tabell med 12 kolumner lyckas tills antalet eller ordningen på kolumnerna i någon av tabellerna har ändrats.
• Undvik att bearbeta eller returnera för mycket data. Begränsa resultatet så tidigt som möjligt i procedurkoden så att alla efterföljande åtgärder som utförs av proceduren görs med hjälp av den minsta möjliga datauppsättningen. Skicka bara viktiga data till klientprogrammet. Det är effektivare än att skicka extra data i nätverket och tvinga klientprogrammet att arbeta med onödigt stora resultatuppsättningar.
• Använd explicita transaktioner med HJÄLP av BEGIN/COMMIT TRANSACTION och håll transaktionerna så korta som möjligt. Längre transaktioner innebär längre postlåsning och en större risk för dödläge.
• Använd Transact-SQL TRY... CATCH-funktion för felhantering i en procedur. FÖRSÖKA... CATCH kan kapsla in ett helt block med Transact-SQL-instruktioner. Detta ger inte bara mindre prestandakostnader, det gör också felrapportering mer exakt med betydligt mindre programmering.
• Använd nyckelordet DEFAULT i alla tabellkolumner som refereras till av CREATE TABLE eller ALTER TABLE Transact-SQL-instruktioner i brödtexten i proceduren. Detta förhindrar att NULL skickas till kolumner som inte tillåter null-värden.
• Använd NULL eller NOT NULL för varje kolumn i en tillfällig tabell. Alternativen ANSI_DFLT_ON och ANSI_DFLT_OFF styr hur databasmotorn tilldelar null- eller NOT NULL-attributen till kolumner när dessa attribut inte anges i instruktionen CREATE TABLE eller ALTER TABLE. Om en anslutning kör en procedur med andra inställningar för dessa alternativ än anslutningen som skapade proceduren, kan kolumnerna i tabellen som skapats för den andra anslutningen ha olika nullabilitet och uppvisa olika beteende. Om NULL eller NOT NULL uttryckligen anges för varje kolumn skapas de temporära tabellerna med samma nullbarhet för alla anslutningar som kör proceduren.
• Använd ändringsinstruktioner som konverterar null-värden och inkluderar logik som eliminerar rader med null-värden från frågor. Tänk på att null i Transact-SQL inte är ett tomt eller "ingenting"-värde. Det är en platshållare för ett okänt värde och kan orsaka oväntat beteende, särskilt när du frågar efter resultatuppsättningar eller använder AGGREGATE-funktioner.
• Använd UNION ALL-operatorn i stället för UNION- eller OR-operatorerna, såvida det inte finns ett specifikt behov av distinkta värden. UNION ALL-operatorn kräver mindre bearbetningskostnader eftersom dubbletter inte filtreras bort från resultatuppsättningen.

Anmärkningar

Det finns ingen fördefinierad maximal storlek för en procedur.

Variabler som anges i proceduren kan vara användardefinierade variabler eller systemvariabler, till exempel @@SPID.

När en procedur körs för första gången kompileras den för att fastställa en optimal åtkomstplan för att hämta data. Efterföljande körningar av proceduren kan återanvända planen som redan har genererats om den fortfarande finns kvar i plancachen för databasmotorn.

En eller flera procedurer kan köras automatiskt när SQL Server startar. Procedurerna måste skapas av systemadministratören master i databasen och köras under den fasta serverrollen sysadmin som en bakgrundsprocess. Procedurerna kan inte ha några indata- eller utdataparametrar. Mer information finns i Kör en lagrad procedur.

Procedurer kapslas när en procedur anropar en annan eller kör hanterad kod genom att referera till en CLR-rutin, typ eller aggregering. Procedurer och hanterade kodreferenser kan kapslas upp till 32 nivåer. Kapslingsnivån ökar med en när den anropade proceduren eller den hanterade kodreferensen börjar köras och minskar med en när den anropade proceduren eller referensen för hanterad kod slutför körningen. Metoder som anropas inifrån den hanterade koden räknas inte mot gränsen för kapslingsnivå. Men när en CLR-lagrad procedur utför dataåtkomståtgärder via den hanterade SQL Server-providern läggs ytterligare en kapslingsnivå till i övergången från hanterad kod till SQL.

Om du försöker överskrida den maximala kapslingsnivån misslyckas hela anropskedjan. Du kan använda funktionen @@NESTLEVEL för att returnera kapslingsnivån för den aktuella lagrade procedurkörningen.

Samverkan

Databasmotorn sparar inställningarna för både SET QUOTED_IDENTIFIER och SET ANSI_NULLS när en Transact-SQL procedur skapas eller ändras. De här ursprungliga inställningarna används när proceduren körs. Därför ignoreras alla klientsessionsinställningar för SET QUOTED_IDENTIFIER och SET ANSI_NULLS när proceduren körs.

Andra SET-alternativ, till exempel SET ARITHABORT, SET ANSI_WARNINGS eller SET ANSI_PADDINGS sparas inte när en procedur skapas eller ändras. Om logiken i proceduren är beroende av en viss inställning ska du inkludera en SET-instruktion i början av proceduren för att garantera lämplig inställning. När en SET-instruktion körs från en procedur gäller inställningen endast tills proceduren har slutförts. Inställningen återställs sedan till det värde som proceduren hade när den anropades. Detta gör det möjligt för enskilda klienter att ange de alternativ de vill ha utan att påverka logiken i proceduren.

En SET-instruktion kan anges i en procedur, förutom SET SHOWPLAN_TEXT och SET SHOWPLAN_ALL. Dessa måste vara de enda uttrycken i batchen. Det valda SET-alternativet gäller fortfarande under körningen av proceduren och återgår sedan till den tidigare inställningen.

Begränsningar och restriktioner

CREATE PROCEDURE-instruktionen kan inte kombineras med andra Transact-SQL-instruktioner i en enda batch.

Följande instruktioner kan inte användas någonstans i brödtexten i en lagrad procedur.

En procedur kan referera till tabeller som ännu inte finns. Vid skapande utförs endast syntaxkontroll. Proceduren kompileras inte förrän den körs för första gången. Endast under kompileringen refereras alla objekt i den åtgärdade proceduren. Därför kan en syntaktiskt korrekt procedur som refererar till tabeller som inte finns skapas. Proceduren misslyckas dock vid körningen om de refererade tabellerna inte finns.

Du kan inte ange ett funktionsnamn som ett standardvärde för parametern eller som värdet som skickas till en parameter när du kör en procedur. Du kan dock skicka en funktion som en variabel som visas i följande exempel.

-- Passing the function value as a variable.
DECLARE @CheckDate DATETIME = GETDATE();
EXEC dbo.uspGetWhereUsedProductID 819, @CheckDate;
GO

Om proceduren gör ändringar på en fjärrinstans av SQL Server kan ändringarna inte återställas. Fjärrprocedurer deltar inte i transaktioner.

För att databasmotorn ska referera till rätt metod när den är överbelastad i .NET Framework måste metoden som anges i satsen EXTERNAL NAME ha följande egenskaper:

• Deklareras som en statisk metod.
• Ta emot samma antal parametrar som antalet parametrar i proceduren.
• Använd parametertyper som är kompatibla med datatyperna för motsvarande parametrar i SQL Server-proceduren. Information om hur du matchar SQL Server-datatyper till .NET Framework-datatyper finns i Mappa CLR-parameterdata.

Metainformation

I följande tabell visas de katalogvyer och dynamiska hanteringsvyer som du kan använda för att returnera information om lagrade procedurer.

Om du vill beräkna storleken på en kompilerad procedur använder du följande prestandaövervakareräknare.

¹ Dessa räknare är tillgängliga för olika kategorier av cacheobjekt, inklusive ad hoc Transact-SQL, förberedd Transact-SQL, procedurer, utlösare och så vidare. Mer information finns i SQL Server, Planera cacheobjekt.

Permissions

Kräver CREATE PROCEDURE behörighet i databasen och ALTER behörighet för schemat där proceduren skapas, eller kräver medlemskap i db_ddladmin fast databasroll.

För CLR-lagrade procedurer kräver ägarskap för sammansättningen som refereras i satsen EXTERNT NAMN eller REFERENCES behörighet för den sammansättningen.

SKAPA PROCEDUR och minnesoptimerade tabeller

Minnesoptimerade tabeller kan nås via både traditionella och internt kompilerade lagrade procedurer. Interna procedurer är i de flesta fall det effektivare sättet. Mer information finns i Internt kompilerade lagrade procedurer.

Följande exempel visar hur du skapar en internt kompilerad lagrad procedur som har åtkomst till en minnesoptimerad tabell dbo.Departments:

CREATE PROCEDURE dbo.usp_add_kitchen @dept_id INT, @kitchen_count INT NOT NULL
WITH EXECUTE AS OWNER, SCHEMABINDING, NATIVE_COMPILATION
AS
BEGIN ATOMIC WITH (TRANSACTION ISOLATION LEVEL = SNAPSHOT, LANGUAGE = N'us_english')

UPDATE dbo.Departments
SET kitchen_count = ISNULL(kitchen_count, 0) + @kitchen_count
WHERE ID = @dept_id
END;
GO

En procedur som skapas utan NATIVE_COMPILATION kan inte ändras till en internt kompilerad lagrad procedur.

En diskussion om programmering i inbyggda kompilerade lagrade procedurer, frågeytan som stöds och operatorer finns i Funktioner som stöds för internt kompilerade T-SQL-moduler.

Examples

Grundläggande syntax

Exempel i det här avsnittet visar de grundläggande funktionerna i CREATE PROCEDURE-instruktionen med den minsta syntax som krävs.

A. Skapa en Transact-SQL procedur

I följande exempel skapas en lagrad procedur som returnerar alla anställda (för- och efternamn som angetts), deras jobbtitlar och deras avdelningsnamn från en vy i databasen AdventureWorks2022. Den här proceduren använder inga parametrar. Exemplet visar sedan tre metoder för att utföra proceduren.

CREATE PROCEDURE HumanResources.uspGetAllEmployees
AS
    SET NOCOUNT ON;
    SELECT LastName, FirstName, JobTitle, Department
    FROM HumanResources.vEmployeeDepartment;
GO

SELECT * FROM HumanResources.vEmployeeDepartment;

Proceduren uspGetEmployees kan köras på följande sätt:

EXECUTE HumanResources.uspGetAllEmployees;
GO
-- Or
EXEC HumanResources.uspGetAllEmployees;
GO
-- Or, if this procedure is the first statement within a batch:
HumanResources.uspGetAllEmployees;

B. Returnera mer än en resultatuppsättning

Följande procedur returnerar två resultatuppsättningar.

CREATE PROCEDURE dbo.uspMultipleResults
AS
SELECT TOP(10) BusinessEntityID, Lastname, FirstName FROM Person.Person;
SELECT TOP(10) CustomerID, AccountNumber FROM Sales.Customer;
GO

C. Skapa en CLR-lagrad procedur

I följande exempel skapas proceduren GetPhotoFromDB som refererar till GetPhotoFromDB metoden för LargeObjectBinary klassen i HandlingLOBUsingCLR sammansättningen. Innan proceduren skapas HandlingLOBUsingCLR registreras sammansättningen i den lokala databasen. Exemplet förutsätter att en sammansättning som skapats från assembly_bits.

Gäller för: SQL Server 2008 (10.0.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview, när du använder en sammansättning som skapats från assembly_bits.

CREATE ASSEMBLY HandlingLOBUsingCLR
FROM '\\MachineName\HandlingLOBUsingCLR\bin\Debug\HandlingLOBUsingCLR.dll';
GO
CREATE PROCEDURE dbo.GetPhotoFromDB
(
    @ProductPhotoID INT
    , @CurrentDirectory NVARCHAR(1024)
    , @FileName NVARCHAR(1024)
)
AS EXTERNAL NAME HandlingLOBUsingCLR.LargeObjectBinary.GetPhotoFromDB;
GO

Skicka parametrar

Exempel i det här avsnittet visar hur du använder indata- och utdataparametrar för att skicka värden till och från en lagrad procedur.

D. Skapa en procedur med indataparametrar

I följande exempel skapas en lagrad procedur som returnerar information för en viss medarbetare genom att ange värden för medarbetarens förnamn och efternamn. Den här proceduren accepterar endast exakta matchningar för de parametrar som skickas.

IF OBJECT_ID ( 'HumanResources.uspGetEmployees', 'P' ) IS NOT NULL
    DROP PROCEDURE HumanResources.uspGetEmployees;
GO
CREATE PROCEDURE HumanResources.uspGetEmployees
    @LastName NVARCHAR(50),
    @FirstName NVARCHAR(50)
AS

    SET NOCOUNT ON;
    SELECT FirstName, LastName, JobTitle, Department
    FROM HumanResources.vEmployeeDepartment
    WHERE FirstName = @FirstName AND LastName = @LastName;
GO

Proceduren uspGetEmployees kan köras på följande sätt:

EXECUTE HumanResources.uspGetEmployees N'Ackerman', N'Pilar';
-- Or
EXEC HumanResources.uspGetEmployees @LastName = N'Ackerman', @FirstName = N'Pilar';
GO
-- Or
EXECUTE HumanResources.uspGetEmployees @FirstName = N'Pilar', @LastName = N'Ackerman';
GO
-- Or, if this procedure is the first statement within a batch:
HumanResources.uspGetEmployees N'Ackerman', N'Pilar';

E. Använda en procedur med jokerteckenparametrar

I följande exempel skapas en lagrad procedur som returnerar information för anställda genom att skicka fullständiga eller partiella värden för medarbetarens förnamn och efternamn. Det här procedurmönstret matchar de parametrar som skickas eller, om de inte anges, använder den förinställda standardinställningen (efternamn som börjar med bokstaven D).

IF OBJECT_ID ( 'HumanResources.uspGetEmployees2', 'P' ) IS NOT NULL
    DROP PROCEDURE HumanResources.uspGetEmployees2;
GO
CREATE PROCEDURE HumanResources.uspGetEmployees2
    @LastName NVARCHAR(50) = N'D%',
    @FirstName NVARCHAR(50) = N'%'
AS
    SET NOCOUNT ON;
    SELECT FirstName, LastName, JobTitle, Department
    FROM HumanResources.vEmployeeDepartment
    WHERE FirstName LIKE @FirstName AND LastName LIKE @LastName;

Proceduren uspGetEmployees2 kan köras i många kombinationer. Här visas bara några få möjliga kombinationer.

EXECUTE HumanResources.uspGetEmployees2;
-- Or
EXECUTE HumanResources.uspGetEmployees2 N'Wi%';
-- Or
EXECUTE HumanResources.uspGetEmployees2 @FirstName = N'%';
-- Or
EXECUTE HumanResources.uspGetEmployees2 N'[CK]ars[OE]n';
-- Or
EXECUTE HumanResources.uspGetEmployees2 N'Hesse', N'Stefen';
-- Or
EXECUTE HumanResources.uspGetEmployees2 N'H%', N'S%';

F. Använda OUTPUT-parametrar

I följande exempel skapas proceduren uspGetList . Den här proceduren returnerar en lista över produkter som har priser som inte överstiger ett angivet belopp. Exemplet visar hur du använder flera SELECT instruktioner och flera OUTPUT parametrar. UTDATAparametrar aktiverar en extern procedur, en batch eller mer än en Transact-SQL-instruktion för att få åtkomst till ett värde som angetts under procedurkörningen.

IF OBJECT_ID ( 'Production.uspGetList', 'P' ) IS NOT NULL
    DROP PROCEDURE Production.uspGetList;
GO
CREATE PROCEDURE Production.uspGetList @Product VARCHAR(40)
    , @MaxPrice MONEY
    , @ComparePrice MONEY OUTPUT
    , @ListPrice MONEY OUT
AS
    SET NOCOUNT ON;
    SELECT p.[Name] AS Product, p.ListPrice AS 'List Price'
    FROM Production.Product AS p
    JOIN Production.ProductSubcategory AS s
      ON p.ProductSubcategoryID = s.ProductSubcategoryID
    WHERE s.[Name] LIKE @Product AND p.ListPrice < @MaxPrice;
-- Populate the output variable @ListPprice.
SET @ListPrice = (SELECT MAX(p.ListPrice)
    FROM Production.Product AS p
    JOIN Production.ProductSubcategory AS s
      ON p.ProductSubcategoryID = s.ProductSubcategoryID
    WHERE s.[Name] LIKE @Product AND p.ListPrice < @MaxPrice);
-- Populate the output variable @compareprice.
SET @ComparePrice = @MaxPrice;
GO

Kör uspGetList för att returnera en lista över Adventure Works-produkter (cyklar) som kostar mindre än $700. Parametrarna OUTPUT@Cost och @ComparePrices används med kontroll av flödesspråk för att returnera ett meddelande i fönstret Meddelanden .

DECLARE @ComparePrice MONEY, @Cost MONEY;
EXECUTE Production.uspGetList '%Bikes%', 700,
    @ComparePrice OUT,
    @Cost OUTPUT
IF @Cost <= @ComparePrice
BEGIN
    PRINT 'These products can be purchased for less than
    $'+RTRIM(CAST(@ComparePrice AS VARCHAR(20)))+'.'
END
ELSE
    PRINT 'The prices for all products in this category exceed
    $'+ RTRIM(CAST(@ComparePrice AS VARCHAR(20)))+'.';

Här är den partiella resultatuppsättningen:

Product                     List Price
--------------------------  ----------
Road-750 Black, 58          539.99
Mountain-500 Silver, 40     564.99
Mountain-500 Silver, 42     564.99
...
Road-750 Black, 48          539.99
Road-750 Black, 52          539.99

(14 row(s) affected)

These items can be purchased for less than $700.00.

G. Använda en tabellvärdesparameter

I följande exempel används en tabellvärdesparametertyp för att infoga flera rader i en tabell. Exemplet skapar parametertypen, deklarerar en tabellvariabel för att referera till den, fyller i parameterlistan och skickar sedan värdena till en lagrad procedur. Den lagrade proceduren använder värdena för att infoga flera rader i en tabell.

/* Create a table type. */
CREATE TYPE LocationTableType AS TABLE
( LocationName VARCHAR(50)
, CostRate INT );
GO

/* Create a procedure to receive data for the table-valued parameter. */
CREATE PROCEDURE usp_InsertProductionLocation
    @TVP LocationTableType READONLY
    AS
    SET NOCOUNT ON
    INSERT INTO [AdventureWorks2022].[Production].[Location]
       ([Name]
       , [CostRate]
       , [Availability]
       , [ModifiedDate])
    SELECT *, 0, GETDATE()
    FROM @TVP;
GO

/* Declare a variable that references the type. */
DECLARE @LocationTVP
AS LocationTableType;

/* Add data to the table variable. */
INSERT INTO @LocationTVP (LocationName, CostRate)
    SELECT [Name], 0.00
    FROM
    [AdventureWorks2022].[Person].[StateProvince];

/* Pass the table variable data to a stored procedure. */
EXEC usp_InsertProductionLocation @LocationTVP;
GO

H. Använda en utdatamarkörparameter

I följande exempel används parametern OUTPUT-markör för att skicka en markör som är lokal till en procedur tillbaka till den anropande batchen, proceduren eller utlösaren.

Skapa först proceduren som deklarerar och öppnar sedan en markör i Currency tabellen:

CREATE PROCEDURE dbo.uspCurrencyCursor
    @CurrencyCursor CURSOR VARYING OUTPUT
AS
    SET NOCOUNT ON;
    SET @CurrencyCursor = CURSOR
    FORWARD_ONLY STATIC FOR
      SELECT CurrencyCode, Name
      FROM Sales.Currency;
    OPEN @CurrencyCursor;
GO

Kör sedan en batch som deklarerar en lokal markörvariabel, kör proceduren för att tilldela markören till den lokala variabeln och hämtar sedan raderna från markören.

DECLARE @MyCursor CURSOR;
EXEC dbo.uspCurrencyCursor @CurrencyCursor = @MyCursor OUTPUT;
WHILE (@@FETCH_STATUS = 0)
BEGIN;
    FETCH NEXT FROM @MyCursor;
END;
CLOSE @MyCursor;
DEALLOCATE @MyCursor;
GO

Ändra data med hjälp av en lagrad procedur

Exempel i det här avsnittet visar hur du infogar eller ändrar data i tabeller eller vyer genom att inkludera en DML-instruktion (Data Manipulation Language) i definitionen av proceduren.

I. Använda UPDATE i en lagrad procedur

I följande exempel används en UPDATE-instruktion i en lagrad procedur. Proceduren tar en indataparameter @NewHours och en utdataparameter @RowCount. Parametervärdet @NewHours används i UPDATE-instruktionen för att uppdatera kolumnen VacationHours i tabellen HumanResources.Employee. Utdataparametern @RowCount används för att returnera antalet rader som påverkas till en lokal variabel. Ett CASE-uttryck används i SET-satsen för att villkorligt fastställa värdet som har angetts för VacationHours. När medarbetaren betalas varje timme (SalariedFlag = 0) VacationHours anges till det aktuella antalet timmar plus det värde som anges i @NewHours. Annars VacationHours anges värdet som anges i @NewHours.

CREATE PROCEDURE HumanResources.Update_VacationHours
@NewHours SMALLINT, @Rowcount INT OUTPUT
AS
SET NOCOUNT ON;
UPDATE HumanResources.Employee
SET VacationHours =
    ( CASE
        WHEN SalariedFlag = 0 THEN VacationHours + @NewHours
        ELSE @NewHours
        END
    )
WHERE CurrentFlag = 1;
SET @Rowcount = @@rowcount;

GO
DECLARE @Rowcount INT
EXEC HumanResources.Update_VacationHours 40, @Rowcount OUTPUT
PRINT @Rowcount;

Felhantering

Exempel i det här avsnittet visar metoder för att hantera fel som kan uppstå när den lagrade proceduren körs.

J. Använd TRY... FÅNGA

Följande exempel använder TRY... CATCH-konstruktion för att returnera felinformation som fångas under körningen av en lagrad procedur.

CREATE PROCEDURE Production.uspDeleteWorkOrder ( @WorkOrderID INT )
AS
SET NOCOUNT ON;
BEGIN TRY
  BEGIN TRANSACTION
  -- Delete rows from the child table, WorkOrderRouting, for the specified work order.
    DELETE FROM Production.WorkOrderRouting
    WHERE WorkOrderID = @WorkOrderID;
  -- Delete the rows from the parent table, WorkOrder, for the specified work order.
    DELETE FROM Production.WorkOrder
    WHERE WorkOrderID = @WorkOrderID;
  COMMIT
END TRY

BEGIN CATCH
  -- Determine if an error occurred.
  IF @@TRANCOUNT > 0
    ROLLBACK

  -- Return the error information.
  DECLARE @ErrorMessage NVARCHAR(4000), @ErrorSeverity INT;
  SELECT @ErrorMessage = ERROR_MESSAGE(),@ErrorSeverity = ERROR_SEVERITY();
  RAISERROR(@ErrorMessage, @ErrorSeverity, 1);
END CATCH;

GO
EXEC Production.uspDeleteWorkOrder 13;
GO
/* Intentionally generate an error by reversing the order in which rows
   are deleted from the parent and child tables. This change does not
   cause an error when the procedure definition is altered, but produces
   an error when the procedure is executed.
*/
ALTER PROCEDURE Production.uspDeleteWorkOrder ( @WorkOrderID INT )
AS

BEGIN TRY
  BEGIN TRANSACTION
  -- Delete the rows from the parent table, WorkOrder, for the specified work order.
    DELETE FROM Production.WorkOrder
    WHERE WorkOrderID = @WorkOrderID;

  -- Delete rows from the child table, WorkOrderRouting, for the specified work order.
    DELETE FROM Production.WorkOrderRouting
    WHERE WorkOrderID = @WorkOrderID;
  COMMIT TRANSACTION
END TRY

BEGIN CATCH
  -- Determine if an error occurred.
  IF @@TRANCOUNT > 0
    ROLLBACK TRANSACTION

  -- Return the error information.
  DECLARE @ErrorMessage NVARCHAR(4000), @ErrorSeverity INT;
  SELECT @ErrorMessage = ERROR_MESSAGE(),@ErrorSeverity = ERROR_SEVERITY();
  RAISERROR(@ErrorMessage, @ErrorSeverity, 1);
END CATCH;
GO
-- Execute the altered procedure.
EXEC Production.uspDeleteWorkOrder 15;
GO
DROP PROCEDURE Production.uspDeleteWorkOrder;

Fördunkla procedurdefinitionen

Exempel i det här avsnittet visar hur du döljer definitionen av den lagrade proceduren.

K. Använd alternativet MED KRYPTERING

I följande exempel skapas proceduren HumanResources.uspEncryptThis .

Gäller för: SQL Server 2008 (10.0.x) och senare versioner, Azure SQL Database, SQL Database i Microsoft Fabric Preview.

CREATE PROCEDURE HumanResources.uspEncryptThis
WITH ENCRYPTION
AS
    SET NOCOUNT ON;
    SELECT BusinessEntityID, JobTitle, NationalIDNumber,
        VacationHours, SickLeaveHours
    FROM HumanResources.Employee;
GO

Alternativet WITH ENCRYPTION döljer definitionen av proceduren när du frågar systemkatalogen eller använder metadatafunktioner, vilket visas i följande exempel.

Kör sp_helptext:

EXEC sp_helptext 'HumanResources.uspEncryptThis';

Här är resultatet.

The text for object 'HumanResources.uspEncryptThis' is encrypted.

Fråga sys.sql_modules katalogvyn direkt:

SELECT definition FROM sys.sql_modules
WHERE object_id = OBJECT_ID('HumanResources.uspEncryptThis');

Här är resultatet.

definition
--------------------------------
NULL

Tvinga proceduren att kompilera om

Exempel i det här avsnittet använder WITH RECOMPILE-satsen för att tvinga proceduren att kompilera om varje gång den körs.

L. Använd alternativet MED KOMPILERA OM

WITH RECOMPILE Satsen är användbar när parametrarna som anges i proceduren inte är typiska och när en ny körningsplan inte ska cachelagras eller lagras i minnet.

IF OBJECT_ID ( 'dbo.uspProductByVendor', 'P' ) IS NOT NULL
    DROP PROCEDURE dbo.uspProductByVendor;
GO
CREATE PROCEDURE dbo.uspProductByVendor @Name VARCHAR(30) = '%'
WITH RECOMPILE
AS
    SET NOCOUNT ON;
    SELECT v.Name AS 'Vendor name', p.Name AS 'Product name'
    FROM Purchasing.Vendor AS v
    JOIN Purchasing.ProductVendor AS pv
      ON v.BusinessEntityID = pv.BusinessEntityID
    JOIN Production.Product AS p
      ON pv.ProductID = p.ProductID
    WHERE v.Name LIKE @Name;

Ange säkerhetskontexten

Exempel i det här avsnittet använder EXECUTE AS-satsen för att ange säkerhetskontexten där den lagrade proceduren körs.

M. Använda EXECUTE AS-satsen

I följande exempel visas hur du använder EXECUTE AS-satsen för att ange säkerhetskontexten där en procedur kan köras. I exemplet anger alternativet CALLER att proceduren kan köras i kontexten för den användare som anropar den.

CREATE PROCEDURE Purchasing.uspVendorAllInfo
WITH EXECUTE AS CALLER
AS
    SET NOCOUNT ON;
    SELECT v.Name AS Vendor, p.Name AS 'Product name',
      v.CreditRating AS 'Rating',
      v.ActiveFlag AS Availability
    FROM Purchasing.Vendor v
    INNER JOIN Purchasing.ProductVendor pv
      ON v.BusinessEntityID = pv.BusinessEntityID
    INNER JOIN Production.Product p
      ON pv.ProductID = p.ProductID
    ORDER BY v.Name ASC;
GO

N. Skapa anpassade behörighetsuppsättningar

I följande exempel används EXECUTE AS för att skapa anpassade behörigheter för en databasåtgärd. Vissa åtgärder, till exempel TRUNCATE TABLE, har inte behörigheter som kan beviljas. Genom att införliva TRUNCATE TABLE-instruktionen i en lagrad procedur och ange att proceduren ska köras som en användare som har behörighet att ändra tabellen, kan du utöka behörigheterna för att trunkera tabellen till den användare som du beviljar EXECUTE-behörigheter för proceduren.

CREATE PROCEDURE dbo.TruncateMyTable
WITH EXECUTE AS SELF
AS TRUNCATE TABLE MyDB..MyTable;

Exempel: Azure Synapse Analytics and Analytics Platform System (PDW)

O. Skapa en lagrad procedur som kör en SELECT-instruktion

Det här exemplet visar den grundläggande syntaxen för att skapa och köra en procedur. När du kör en batch måste CREATE PROCEDURE vara den första instruktionen. Om du till exempel vill skapa följande lagrade procedur i AdventureWorksPDW2022 anger du databaskontexten först och kör sedan INSTRUKTIONEN SKAPA PROCEDUR.

-- Uses AdventureWorksDW database

--Run CREATE PROCEDURE as the first statement in a batch.
CREATE PROCEDURE Get10TopResellers
AS
BEGIN
    SELECT TOP (10) r.ResellerName, r.AnnualSales
    FROM DimReseller AS r
    ORDER BY AnnualSales DESC, ResellerName ASC;
END
;
GO

--Show 10 Top Resellers
EXEC Get10TopResellers;

Se även

• ALTER PROCEDURE (Transact-SQL)
• Kontroll av flödesspråk (Transact-SQL)
• Markörer
• Datatyper (Transact-SQL)
• DECLARE @local_variable (Transact-SQL)
• DROP-PROCEDUR (Transact-SQL)
• KÖR (Transact-SQL)
• KÖR SOM (Transact-SQL)
• Lagrade Procedurer (Databasmotor)
• sp_procoption (Transact-SQL)
• sp_recompile (Transact-SQL)
• sys.sql_modules (Transact-SQL)
• sys.parameters (Transact-SQL)
• sys.procedures (Transact-SQL)
• sys.sql_expression_dependencies (Transact-SQL)
• sys.assembly_modules (Transact-SQL)
• sys.numbered_procedures (Transact-SQL)
• sys.numbered_procedure_parameters (Transact-SQL)
• OBJECT_DEFINITION (Transact-SQL)
• Skapa en lagrad procedur
• Använda Table-Valued parametrar (databasmotor)
• sys.dm_sql_referenced_entities (Transact-SQL)
• sys.dm_sql_referencing_entities (Transact-SQL)