Självstudie: Använda Transact-SQL-redigeraren för att skapa databasobjekt – Azure Data Studio

Artikel
10/16/2024

Att skapa och köra frågor, lagrade procedurer, skript osv. är grundläggande uppgifter för databasproffs. Den här självstudien visar de viktigaste funktionerna i T-SQL-redigeraren för att skapa databasobjekt.

I den här självstudien får du lära dig hur du använder Azure Data Studio för att:

Sök databasobjekt
Redigera tabelldata
Använda kodfragment för att snabbt skriva T-SQL
Visa information om databasobjekt med hjälp av Peek Definition och Gå till definition

Förutsättningar

Den här självstudien kräver SQL Server eller Azure SQL Database TutorialDB. Om du vill skapa TutorialDB-databasen slutför du någon av följande snabbstarter:

Leta snabbt upp ett databasobjekt och utför en gemensam uppgift

Azure Data Studio tillhandahåller en sökwidget för att snabbt hitta databasobjekt. Resultatlistan innehåller en snabbmeny för vanliga uppgifter som är relevanta för det valda objektet, till exempel Redigera data för en tabell.

Öppna sidofältet SERVRAR (Ctrl+G), expandera Databaser och välj TutorialDB.
Öppna TutorialDB-instrumentpanelen genom att högerklicka på TutorialDB och välja Hantera på snabbmenyn:
Högerklicka på dbo på instrumentpanelen. Kunder (i sökwidgeten) och väljer Redigera data.

Dricks

För databaser med många objekt använder du sökwidgeten för att snabbt hitta tabellen, vyn osv. som du letar efter.
Redigera kolumnen E-post på den första raden, skriv orlando0@adventure-works.comoch tryck på Retur för att spara ändringen.

Använda T-SQL-kodfragment för att skapa lagrade procedurer

Azure Data Studio innehåller många inbyggda T-SQL-kodfragment för att snabbt skapa instruktioner.

Öppna en ny frågeredigerare genom att trycka på Ctrl+N.
Skriv sql i redigeraren, pil ned till sqlCreateStoredProcedure och tryck på tabbtangenten (eller Retur) för att läsa in kodfragmentet skapa lagrad procedur.
Kodfragmentet skapa lagrad procedur har två fält konfigurerade för snabbredigering, StoredProcedureName och SchemaName. Välj StoredProcedureName, högerklicka och välj Ändra alla förekomster. Skriv nu getCustomer och alla StoredProcedureName-poster ändras för att hämtaCustomer.
Ändra alla förekomster av SchemaName till dbo.

Kodfragmentet innehåller platshållarparametrar och brödtext som behöver uppdateras. EXECUTE-instruktionen innehåller också platshållartext eftersom den inte vet hur många parametrar proceduren kommer att ha. I den här självstudien uppdaterar du kodfragmentet så att det ser ut som följande kod:

-- Create a new stored procedure called 'getCustomer' in schema 'dbo'
-- Drop the stored procedure if it already exists
IF EXISTS (
SELECT *
FROM INFORMATION_SCHEMA.ROUTINES
WHERE SPECIFIC_SCHEMA = N'dbo'
AND SPECIFIC_NAME = N'getCustomer'
)
DROP PROCEDURE dbo.getCustomer
GO
-- Create the stored procedure in the specified schema
CREATE PROCEDURE dbo.getCustomer
@ID int
-- add more stored procedure parameters here
AS
-- body of the stored procedure
SELECT  c.CustomerId, 
c.Name, 
c.Location, 
c.Email
FROM dbo.Customers c
WHERE c.CustomerId = @ID
FOR JSON PATH

GO
-- example to execute the stored procedure we just created
EXECUTE dbo.getCustomer 1
GO

Om du vill skapa den lagrade proceduren och ge den en testkörning trycker du på F5.

Den lagrade proceduren har nu skapats och fönstret RESULTS visar den returnerade kunden i JSON. Om du vill se formaterad JSON klickar du på den returnerade posten.

Använda peek-definition

Azure Data Studio ger möjlighet att visa en objektdefinition med hjälp av funktionen för granskningsdefinition. Det här avsnittet skapar en andra lagrad procedur och använder en tittdefinition för att se vilka kolumner som finns i en tabell för att snabbt skapa brödtexten i den lagrade proceduren.

Öppna en ny redigerare genom att trycka på Ctrl+N.
Skriv sql i redigeraren, pil ned till sqlCreateStoredProcedure och tryck på tabbtangenten (eller Retur) för att läsa in kodfragmentet skapa lagrad procedur.
Ange setCustomer för StoredProcedureName och dbo för SchemaName
@param Ersätt platshållarna med följande parameterdefinition:
```
@json_val nvarchar(max)
```
Ersätt brödtexten i den lagrade proceduren med följande kod:
```
INSERT INTO dbo.Customers
```
Högerklicka på dbo på den INSERT-rad som du nyss lade till. Kunder och välj Granska definition.
Tabelldefinitionen visas så att du snabbt kan se vilka kolumner som finns i tabellen. Se kolumnlistan för att enkelt slutföra instruktionerna för den lagrade proceduren. Slutför skapandet av INSERT-instruktionen som du lade till tidigare för att slutföra brödtexten i den lagrade proceduren och stäng fönstret för granskningsdefinition:
```
INSERT INTO dbo.Customers (CustomerId, Name, Location, Email)
    SELECT CustomerId, Name, Location, Email
    FROM OPENJSON (@json_val)
    WITH(   CustomerId int, 
            Name nvarchar(50), 
            Location nvarchar(50), 
            Email nvarchar(50)
 )
```
Ta bort (eller kommentera ut) kommandot EXECUTE längst ned i frågan.

Hela instruktionen bör se ut som följande kod:

-- Create a new stored procedure called 'setCustomer' in schema 'dbo'
-- Drop the stored procedure if it already exists
IF EXISTS (
SELECT *
    FROM INFORMATION_SCHEMA.ROUTINES
    WHERE SPECIFIC_SCHEMA = N'dbo'
    AND SPECIFIC_NAME = N'setCustomer'
)
DROP PROCEDURE dbo.setCustomer
GO
-- Create the stored procedure in the specified schema
CREATE PROCEDURE dbo.setCustomer
    @json_val nvarchar(max) 
AS
    -- body of the stored procedure
    INSERT INTO dbo.Customers (CustomerId, Name, Location, Email)
    SELECT CustomerId, Name, Location, Email
    FROM OPENJSON (@json_val)
    WITH(   CustomerId int, 
            Name nvarchar(50), 
            Location nvarchar(50), 
            Email nvarchar(50)
    )
GO

Om du vill skapa den lagrade proceduren setCustomer trycker du på F5.

Använd spara frågeresultat som JSON för att testa den lagrade proceduren setCustomer

Den setCustomer-lagrade proceduren som skapades i föregående avsnitt kräver att JSON-data skickas till parametern @json_val . Det här avsnittet visar hur du hämtar en korrekt formaterad JSON-bit för att gå in i parametern så att du kan testa den lagrade proceduren.

Högerklicka på dbo i sidofältet SERVRAR. Tabellen Kunder och klicka på VÄLJ DE 1 000 översta raderna.
Välj den första raden i resultatvyn, kontrollera att hela raden är markerad (klicka på nummer 1 i kolumnen längst till vänster) och välj Spara som JSON.
Ändra mappen till en plats som du kommer ihåg så att du kan ta bort filen senare (till exempel skrivbord) och klicka på Spara. Den JSON-formaterade filen öppnas.
Välj JSON-data i redigeraren och kopiera dem.
Öppna en ny redigerare genom att trycka på Ctrl+N.
Föregående steg visar hur du enkelt kan hämta korrekt formaterade data för att slutföra anropet till setCustomer-proceduren . Du kan se att följande kod använder samma JSON-format med ny kundinformation så att vi kan testa setCustomer-proceduren . -instruktionen innehåller syntax för att deklarera parametern och köra de nya get- och set-procedurerna. Du kan klistra in kopierade data från föregående avsnitt och redigera dem så att de är samma som i följande exempel, eller helt enkelt klistra in följande instruktion i frågeredigeraren.
```
-- example to execute the stored procedure we just created
declare @json nvarchar(max) =
N'[
    {
        "CustomerId": 5,
        "Name": "Lucy",
        "Location": "Canada",
        "Email": "lucy0@adventure-works.com"
    }
]'

EXECUTE dbo.setCustomer @json_val = @json
GO

EXECUTE dbo.getCustomer @ID = 5
```
Kör skriptet genom att trycka på F5. Skriptet infogar en ny kund och returnerar den nya kundens information i JSON-format. Klicka på resultatet för att öppna en formaterad vy.

Nästa steg

I den här självstudiekursen lärde du dig att:

Schemaobjekt för snabbsökning
Redigera tabelldata
Skriva T-SQL-skript med hjälp av kodfragment
Lär dig mer om information om databasobjekt med hjälp av Peek Definition och Go to Definition

Om du vill lära dig hur du aktiverar widgeten med fem långsammaste frågor slutför du nästa självstudie:

Aktivera insiktswidgeten för långsamma frågor

Dela via