Genomgång för prestandafunktionerna i SQL Server på Linux

2025-07-03

gäller för:SQL Server – Linux

Om du är en Linux-användare som är nybörjare på SQL Server går följande uppgifter igenom några av prestandafunktionerna. Dessa är inte unika eller specifika för Linux, men det hjälper dig att ge dig en uppfattning om områden att undersöka ytterligare. I varje exempel finns en länk till djupdokumentationen för det området.

Not

De följande exemplen använder exempeldatabasen AdventureWorks2022. Anvisningar om hur du hämtar och installerar den här exempeldatabasen finns i Migrera en SQL Server-databas från Windows till Linux med hjälp av säkerhetskopiering och återställning.

Skapa ett kolumnlagringsindex

Ett kolumnlagringsindex är en teknik för att lagra och köra frågor mot stora datalager i ett kolumnformat, som kallas kolumnlagring.

Lägg till ett columnstore-index i tabellen SalesOrderDetail genom att köra följande Transact-SQL kommandon:

CREATE NONCLUSTERED COLUMNSTORE INDEX [IX_SalesOrderDetail_ColumnStore]
    ON Sales.SalesOrderDetail(UnitPrice, OrderQty, ProductID);
GO

Kör följande fråga som använder kolumnlagringsindexet för att skanna tabellen:

SELECT ProductID,
       SUM(UnitPrice) AS SumUnitPrice,
       AVG(UnitPrice) AS AvgUnitPrice,
       SUM(OrderQty) AS SumOrderQty,
       AVG(OrderQty) AS AvgOrderQty
FROM Sales.SalesOrderDetail
GROUP BY ProductID
ORDER BY ProductID;

Kontrollera att kolumnlagringsindexet användes genom att leta upp object_id för kolumnlagringsindexet och bekräfta att det visas i användningsstatistiken för tabellen SalesOrderDetail:

SELECT *
FROM sys.indexes
WHERE name = 'IX_SalesOrderDetail_ColumnStore';
GO

SELECT *
FROM sys.dm_db_index_usage_stats
WHERE database_id = DB_ID('AdventureWorks2022')
      AND object_id = OBJECT_ID('AdventureWorks2022.Sales.SalesOrderDetail');

Använda In-Memory OLTP

SQL Server tillhandahåller In-Memory OLTP-funktioner som avsevärt kan förbättra programsystemens prestanda. I det här avsnittet går vi igenom stegen för att skapa en minnesoptimerad tabell som lagras i minnet och en inbyggt kompilerad lagrad procedur som kan komma åt tabellen utan att behöva kompileras eller tolkas.

Konfigurera databas för In-Memory OLTP

Du bör ange databasen till en kompatibilitetsnivå på minst 130 för att använda In-Memory OLTP. Använd följande fråga för att kontrollera den aktuella kompatibilitetsnivån för AdventureWorks2022:
```
USE AdventureWorks2022;
GO

SELECT d.compatibility_level
FROM sys.databases AS d
WHERE d.name = DB_NAME();
GO
```
Om det behövs uppdaterar du nivån till 130:
```
ALTER DATABASE CURRENT
    SET COMPATIBILITY_LEVEL = 130;
GO
```
När en transaktion omfattar både en diskbaserad tabell och en minnesoptimerad tabell är det viktigt att den minnesoptimerade delen av transaktionen fungerar på transaktionsisoleringsnivå med namnet SNAPSHOT. Kör följande för att på ett tillförlitligt sätt framtvinga den här nivån för minnesoptimerade tabeller i en transaktion mellan containrar:
```
ALTER DATABASE CURRENT
    SET MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT = ON;
GO
```

Innan du kan skapa en minnesoptimerad tabell måste du först skapa en minnesoptimerad filgrupp och en container för datafiler:

ALTER DATABASE AdventureWorks2022
    ADD FILEGROUP AdventureWorks_mod CONTAINS MEMORY_OPTIMIZED_DATA;
GO

ALTER DATABASE AdventureWorks2022
    ADD FILE (NAME = 'AdventureWorks_mod', FILENAME = '/var/opt/mssql/data/AdventureWorks_mod') TO FILEGROUP AdventureWorks_mod;
GO

Skapa en minnesoptimerad tabell

Det primära arkivet för minnesoptimerade tabeller är huvudminnet, så till skillnad från diskbaserade tabeller behöver data inte läsas in från disken till minnesbuffertar. Om du vill skapa en minnesoptimerad tabell använder du satsen MEMORY_OPTIMIZED = ON.

Kör följande fråga för att skapa den minnesoptimerade tabellen dbo. ShoppingCart. Som standard sparas data på disken i hållbarhetssyfte (DURABILITY kan också ställas in på att endast spara schemat).

CREATE TABLE dbo.ShoppingCart
(
    ShoppingCartId INT IDENTITY (1, 1) PRIMARY KEY NONCLUSTERED,
    UserId INT NOT NULL INDEX ix_UserId NONCLUSTERED HASH WITH (BUCKET_COUNT = 1000000),
    CreatedDate DATETIME2 NOT NULL,
    TotalPrice MONEY
)
WITH (MEMORY_OPTIMIZED = ON);
GO

Infoga vissa poster i tabellen:

INSERT dbo.ShoppingCart
VALUES (8798, SYSDATETIME(), NULL);

INSERT dbo.ShoppingCart
VALUES (23, SYSDATETIME(), 45.4);

INSERT dbo.ShoppingCart
VALUES (80, SYSDATETIME(), NULL);

INSERT dbo.ShoppingCart
VALUES (342, SYSDATETIME(), 65.4);

Nativt kompilerade lagrade procedurer

SQL Server stöder inbyggda kompilerade lagrade procedurer som har åtkomst till minnesoptimerade tabeller. T-SQL-uttrycken kompileras till maskinkod och lagras som interna DLL:er, vilket ger snabbare dataåtkomst och effektivare frågekörning än traditionell T-SQL. Lagrade procedurer som är markerade med NATIVE_COMPILATION kompileras internt.

Kör följande skript för att skapa en internt kompilerad lagrad procedur som infogar ett stort antal poster i tabellen ShoppingCart:

CREATE PROCEDURE dbo.usp_InsertSampleCarts
@InsertCount INT
WITH NATIVE_COMPILATION, SCHEMABINDING
AS
BEGIN ATOMIC
WITH (TRANSACTION ISOLATION LEVEL = SNAPSHOT, LANGUAGE = N'us_english')
    DECLARE @i AS INT = 0;
    WHILE @i < @InsertCount
        BEGIN
            INSERT INTO dbo.ShoppingCart
            VALUES (1, SYSDATETIME(), NULL);
            SET @i += 1;
        END
END;

Infoga 1 000 000 rader:
```
EXECUTE usp_InsertSampleCarts 1000000;
```
Kontrollera att raderna har infogats:
```
SELECT COUNT(*)
FROM dbo.ShoppingCart;
```

Använd Query Store

Query Store samlar in detaljerad prestandainformation om frågeställningar, exekveringsplaner och exekveringsstatistik.

Före SQL Server 2022 (16.x) är Query Store inte aktiverat som standard och kan aktiveras med ALTER DATABASE:

ALTER DATABASE AdventureWorks2022
    SET QUERY_STORE = ON;

Kör följande fråga för att returnera information om frågor och planer i Query Store:

SELECT Txt.query_text_id,
       Txt.query_sql_text,
       Pl.plan_id,
       Qry.*
FROM sys.query_store_plan AS Pl
     INNER JOIN sys.query_store_query AS Qry
         ON Pl.query_id = Qry.query_id
     INNER JOIN sys.query_store_query_text AS Txt
         ON Qry.query_text_id = Txt.query_text_id;

Fråga dynamiska hanteringsvyer

Dynamiska hanteringsvyer returnerar servertillståndsinformation som kan användas för att övervaka hälsotillståndet för en serverinstans, diagnostisera problem och justera prestanda.

Så här frågar du dm_os_wait vyn för dynamisk hantering av statistik:

SELECT wait_type,
       wait_time_ms
FROM sys.dm_os_wait_stats;

Feedback

Var den här sidan till hjälp?