Not
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
Gäller för:
SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsAnalysplattformssystem (PDW)SQL-analysslutpunkt i Microsoft FabricLager i Microsoft FabricSQL-databas i Microsoft Fabric
Åtkomst till data från en efterföljande rad i samma resultatuppsättning utan användning av en självanslutning från och med SQL Server 2012 (11.x).
LEAD ger tillgång till en rad vid en given fysisk offset som följer den aktuella raden. Använd denna analytiska funktion i en SELECT sats för att jämföra värden i den aktuella raden med värden i en följande rad.
Transact-SQL syntaxkonventioner
Syntax
LEAD ( scalar_expression [ , offset ] [ , default ] ) [ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ partition_by_clause ] order_by_clause )
Arguments
scalar_expression
Värdet som ska returneras baserat på den specificerade offseten. Det är ett uttryck av vilken typ som helst som returnerar ett enda (skalärt) värde. scalar_expression kan inte vara en analytisk funktion.
uppväga
Antalet rader framåt från den aktuella raden från vilken ett värde kan erhållas. Om det inte anges är standardvärdet 1. Offset kan vara en kolumn, delfråga eller annat uttryck som utvärderas till ett positivt heltal eller kan implicit konverteras till bigint. Offset kan inte vara ett negativt värde eller en analytisk funktion.
förvalt
Värdet som ska returneras vid offset ligger utanför partitionens omfattning. Om ett standardvärde inte anges NULL returneras. Standard kan vara en kolumn, delfråga eller annat uttryck, men det kan inte vara en analytisk funktion.
Standard måste vara typkompatibel med scalar_expression.
[ IGNORERA NULLS | RESPECT NULLS ]
Gäller för: SQL Server 2022 (16.x) och senare versioner, Azure SQL Database, Azure SQL Managed Instance, Azure SQL Edge
IGNORE NULLS - Ignorera NULL värden i datamängden när det första värdet beräknas över en partition.
RESPECT NULLS - Respektera NULL värden i datasetet när det första värdet beräknas över en partition.
RESPECT NULLS är standardbeteendet om ett NULLS alternativ inte är specificerat.
Det fanns en buggfix i SQL Server 2022 CU4 relaterad till IGNORE NULLS i LAG och LEAD.
Mer information om det här argumentet i Azure SQL Edge finns i Imputing missing values.
ÖVER ( [ partition_by_clause ] order_by_clause )
partition_by_clause delar upp resultatuppsättningen
FROMsom genereras av -satsen i partitioner som funktionen tillämpas på. Om det inte anges behandlar funktionen alla rader i frågeresultatuppsättningen som en enda grupp.order_by_clause bestämmer ordningen på data innan funktionen tillämpas.
När partition_by_clause anges bestämmer den ordningen på data i varje partition. order_by_clause krävs. För mer information, se SELECT - OVER-klausulen.
Returtyper
Datatypen för den angivna scalar_expression.
NULL returneras om scalar_expression är nullbar eller om standardvärdet är satt till NULL.
LEAD är nondeterministisk. Mer information finns i Deterministiska och nondeterministiska funktioner.
Examples
Kodexemplen i den här artikeln använder AdventureWorks2025- eller AdventureWorksDW2025-exempeldatabasen, som du kan ladda ned från startsidan Microsoft SQL Server Samples och Community Projects.
A. Jämför värden mellan år
Frågan använder funktionen LEAD för att returnera skillnaden i försäljningskvoter för en specifik anställd över kommande år. Eftersom det inte finns något leadvärde tillgängligt för den sista raden returneras standardvärdet noll (0).
USE AdventureWorks2022;
GO
SELECT BusinessEntityID,
YEAR(QuotaDate) AS SalesYear,
SalesQuota AS CurrentQuota,
LEAD(SalesQuota, 1, 0) OVER (ORDER BY YEAR(QuotaDate)) AS NextQuota
FROM Sales.SalesPersonQuotaHistory
WHERE BusinessEntityID = 275 AND YEAR(QuotaDate) IN ('2005', '2006');
Här är resultatet.
BusinessEntityID SalesYear CurrentQuota NextQuota
---------------- ----------- --------------------- ---------------------
275 2005 367000.00 556000.00
275 2005 556000.00 502000.00
275 2006 502000.00 550000.00
275 2006 550000.00 1429000.00
275 2006 1429000.00 1324000.00
275 2006 1324000.00 0.00
B. Jämför värden inom partitioner
Följande exempel använder funktionen LEAD för att jämföra års-hit-till-datums försäljning mellan anställda. Klausulen PARTITION BY specificeras för att dela upp raderna i resultatuppsättningen efter försäljningsområde. Funktionen LEAD tillämpas separat på varje partition och beräkningen startas om för varje partition. Klausulen ORDER BY som anges i OVER klausulen ordnar raderna i varje partition innan funktionen tillämpas. Klausulen ORDER BY i påståendet SELECT ordnar raderna i hela resultatmängden. Eftersom det inte finns något leadvärde tillgängligt för sista raden i varje partition, returneras standardvärdet noll (0).
USE AdventureWorks2022;
GO
SELECT TerritoryName, BusinessEntityID, SalesYTD,
LEAD (SalesYTD, 1, 0) OVER (PARTITION BY TerritoryName ORDER BY SalesYTD DESC) AS NextRepSales
FROM Sales.vSalesPerson
WHERE TerritoryName IN (N'Northwest', N'Canada')
ORDER BY TerritoryName;
Här är resultatet.
TerritoryName BusinessEntityID SalesYTD NextRepSales
----------------------- ---------------- --------------------- ---------------------
Canada 282 2604540.7172 1453719.4653
Canada 278 1453719.4653 0.00
Northwest 284 1576562.1966 1573012.9383
Northwest 283 1573012.9383 1352577.1325
Northwest 280 1352577.1325 0.00
C. Specificera godtyckliga uttryck
Följande exempel visar hur man specificerar olika godtyckliga uttryck och ignorerar NULL värden i LEAD funktionssyntaxen.
CREATE TABLE T (a INT, b INT, c INT);
GO
INSERT INTO T VALUES (1, 1, -3), (2, 2, 4), (3, 1, NULL), (4, 3, 1), (5, 2, NULL), (6, 1, 5);
SELECT b, c,
LEAD(2 * c, b * (SELECT MIN(b) FROM T), -c / 2.0) IGNORE NULLS OVER (ORDER BY a) AS i
FROM T;
Här är resultatet.
b c i
----------- ----------- -----------
1 5 -2
2 NULL NULL
3 1 0
1 NULL 2
2 4 2
1 -3 8
D. Använd IGNORERA NULL för att hitta icke-NULL-värden
Följande exempelfråga demonstrerar användningen av argumentet IGNORE NULLS .
Argumentet IGNORE NULLS används både med LAG och LEAD för att demonstrera substitution av NULL värden för föregående eller nästa icke-NULL-värden.
- Om den föregående raden innehåller
NULL,LAGanvänder den aktuella raden det senaste icke-värdetNULL. - Om nästa rad innehåller en
NULLmedLEAD, så använder den aktuella raden nästa tillgängliga icke-värdeNULL.
DROP TABLE IF EXISTS #test_ignore_nulls;
CREATE TABLE #test_ignore_nulls (column_a int, column_b int);
GO
INSERT INTO #test_ignore_nulls VALUES
(1, 8),
(2, 9),
(3, NULL),
(4, 10),
(5, NULL),
(6, NULL),
(7, 11);
SELECT column_a, column_b,
[Previous value for column_b] = LAG(column_b) IGNORE NULLS OVER (ORDER BY column_a),
[Next value for column_b] = LEAD(column_b) IGNORE NULLS OVER (ORDER BY column_a)
FROM #test_ignore_nulls
ORDER BY column_a;
--cleanup
DROP TABLE #test_ignore_nulls;
column_a column_b Previous value for column_b Next value for column_b
------------ ----------- ------------------------------ ------------------------
1 8 NULL 9
2 9 8 10
3 NULL 9 10
4 10 9 11
5 NULL 10 11
6 NULL 10 11
7 11 10 NULL
E. Använd RESPEKT NULL för att behålla NULL värden
Följande exempelfråga demonstrerar användningen av RESPECT NULLS argumentet, vilket är standardbeteendet om det inte specificeras, till skillnad från argumentet IGNORE NULLS i föregående exempel.
- Om den föregående raden innehöll
NULLmedLAG, så använder den aktuella raden det senaste värdet. - Om nästa rad innehåller en
NULLmedLEAD, så använder den aktuella raden nästa värde.
DROP TABLE IF EXISTS #test_ignore_nulls;
CREATE TABLE #test_ignore_nulls (column_a int, column_b int);
GO
INSERT INTO #test_ignore_nulls VALUES
(1, 8),
(2, 9),
(3, NULL),
(4, 10),
(5, NULL),
(6, NULL),
(7, 11);
SELECT column_a, column_b,
[Previous value for column_b] = LAG(column_b) RESPECT NULLS OVER (ORDER BY column_a),
[Next value for column_b] = LEAD(column_b) RESPECT NULLS OVER (ORDER BY column_a)
FROM #test_ignore_nulls
ORDER BY column_a;
--Identical output
SELECT column_a, column_b,
[Previous value for column_b] = LAG(column_b) OVER (ORDER BY column_a),
[Next value for column_b] = LEAD(column_b) OVER (ORDER BY column_a)
FROM #test_ignore_nulls
ORDER BY column_a;
--cleanup
DROP TABLE #test_ignore_nulls;
column_a column_b Previous value for column_b Next value for column_b
1 8 NULL 9
2 9 8 NULL
3 NULL 9 10
4 10 NULL NULL
5 NULL 10 NULL
6 NULL NULL 11
7 11 NULL NULL
Exempel: Azure Synapse Analytics and Analytics Platform System (PDW)
A. Jämför värden mellan kvartalen
Följande exempel demonstrerar LEAD funktionen. Sökningen erhåller skillnaden i försäljningskvotvärden för en specificerad anställd över efterföljande kalenderkvartal. Eftersom det inte finns något leadvärde tillgängligt efter sista raden används standardvärdet noll (0).
-- Uses AdventureWorks
SELECT CalendarYear AS Year,
CalendarQuarter AS Quarter,
SalesAmountQuota AS SalesQuota,
LEAD(SalesAmountQuota, 1, 0) OVER (ORDER BY CalendarYear, CalendarQuarter) AS NextQuota,
SalesAmountQuota - LEAD(SalesAmountQuota, 1, 0) OVER (ORDER BY CalendarYear, CalendarQuarter) AS Diff
FROM dbo.FactSalesQuota
WHERE EmployeeKey = 272 AND CalendarYear IN (2001, 2002)
ORDER BY CalendarYear, CalendarQuarter;
Här är resultatet.
Year Quarter SalesQuota NextQuota Diff
---- ------- ---------- --------- -------------
2001 3 28000.0000 7000.0000 21000.0000
2001 4 7000.0000 91000.0000 -84000.0000
2001 1 91000.0000 140000.0000 -49000.0000
2002 2 140000.0000 7000.0000 7000.0000
2002 3 7000.0000 154000.0000 84000.0000
2002 4 154000.0000 0.0000 154000.0000