Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Aplica-se a:
SQL ServerBase de Dados SQL do AzureAzure SQL Managed InstanceAzure Synapse AnalyticsEndpoint de análise SQL no Microsoft FabricArmazém no Microsoft FabricBase de dados SQL no Microsoft Fabric
Acede a dados de uma linha subsequente no mesmo conjunto de resultados sem a utilização de uma auto-junção a partir do SQL Server 2012 (11.x).
LEAD proporciona acesso a uma linha num determinado deslocamento físico que segue a linha atual. Use esta função analítica numa SELECT instrução para comparar valores na linha atual com valores na linha seguinte.
Transact-SQL convenções de sintaxe
Sintaxe
LEAD ( scalar_expression [ , offset ] [ , default ] ) [ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ partition_by_clause ] order_by_clause )
Arguments
scalar_expression
O valor a ser devolvido com base no deslocamento especificado. É uma expressão de qualquer tipo que devolve um único valor (escalar). scalar_expression não pode ser uma função analítica.
Deslocamento
O número de linhas a partir da linha atual a partir do qual se obtém um valor. Se não for especificado, o padrão será 1. Deslocamento pode ser uma coluna, subconsulta ou outra expressão que avalia para um inteiro positivo ou pode ser implicitamente convertida em bigint. O deslocamento não pode ser um valor negativo ou uma função analítica.
padrão
O valor a devolver quando deslocado está fora do âmbito da partição. Se não for especificado um valor padrão, NULL é devolvido.
O padrão pode ser uma coluna, subconsulta ou outra expressão, mas não pode ser uma função analítica.
O padrão deve ser compatível com o tipo scalar_expression.
[ IGNORAR NULOS | RESPEITO NULADOS ]
Aplica-se a: SQL Server 2022 (16.x) e versões posteriores, Base de Dados SQL do Azure, Azure SQL Managed Instance, SQL do Azure no Edge
IGNORE NULLS - Ignorar NULL os valores no conjunto de dados ao calcular o primeiro valor sobre uma partição.
RESPECT NULLS - Respeitar NULL os valores no conjunto de dados ao calcular o primeiro valor sobre uma partição.
RESPECT NULLS é o comportamento padrão se uma NULLS opção não for especificada.
Houve uma correção de bug no SQL Server 2022 CU4 relacionada com IGNORE NULLS em LAG e LEAD.
Para obter mais informações sobre esse argumento no SQL do Azure no Edge, consulte Imputando valores ausentes.
TERMINADO ( [ partition_by_clause ] order_by_clause )
partition_by_clause divide o conjunto de resultados produzido pela
FROMcláusula em partições às quais a função é aplicada. Se não for especificada, a função trata todas as linhas do conjunto de resultados da consulta como um único grupo.order_by_clause determina a ordem dos dados antes de a função ser aplicada.
Quando partition_by_clause é especificado, determina a ordem dos dados em cada partição. O order_by_clause é obrigatório. Para mais informações, consulte a Cláusula SELECT - OVER.
Tipos de devolução
O tipo de dado do scalar_expression especificado.
NULL é devolvido se scalar_expression for anulável ou se o padrão for definido para NULL.
LEAD é não determinística. Para mais informações, consulte Funções Determinísticas e Não Determinísticas.
Examples
Os exemplos de código neste artigo utilizam a AdventureWorks2025 base de dados de exemplos ORAdventureWorksDW2025, que pode descarregar do repositório GitHub do Azure Data SQL Samples Repository.
A. Compare valores entre anos
A consulta utiliza a LEAD função para devolver a diferença nas quotas de vendas de um determinado colaborador ao longo dos anos seguintes. Como não há valor inicial disponível para a última linha, o padrão zero (0) é devolvido.
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');
Aqui está o conjunto de resultados.
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. Compare valores dentro das partições
O exemplo seguinte utiliza a LEAD função para comparar as vendas acumuladas entre colaboradores. A PARTITION BY cláusula é especificada para particionar as linhas no resultado definido por território de vendas. A LEAD função é aplicada a cada partição separadamente e o cálculo reinicia-se para cada partição. A ORDER BY cláusula especificada na OVER cláusula ordena as linhas em cada partição antes de a função ser aplicada. A ORDER BY cláusula na SELECT instrução ordena as linhas de todo o conjunto de resultados. Como não existe um valor inicial disponível para a última linha de cada partição, o valor padrão zero (0) é devoluído.
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;
Aqui está o conjunto de resultados.
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. Especificar expressões arbitrárias
O exemplo seguinte demonstra especificar várias expressões arbitrárias e ignorar NULL valores na LEAD sintaxe da função.
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;
Aqui está o conjunto de resultados.
b c i
----------- ----------- -----------
1 5 -2
2 NULL NULL
3 1 0
1 NULL 2
2 4 2
1 -3 8
D. Use IGNORAR NULLS para encontrar valores não-NULL
A seguinte consulta de exemplo demonstra o uso do IGNORE NULLS argumento.
O IGNORE NULLS argumento é usado tanto com o LAG como LEAD para demonstrar a substituição de NULL valores por valores anteriores ou seguintes não-NULL.
- Se a linha anterior contiver
NULL,LAGentão a linha atual usa o valor nãoNULLmais recente. - Se a linha seguinte contiver um
NULLcomLEAD, então a linha atual usa o próximo não-valorNULLdisponível.
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. Use RESPECT NULLS para manter NULL os valores
A seguinte consulta de exemplo demonstra o uso do RESPECT NULLS argumento, que é o comportamento padrão se não especificado, ao contrário do IGNORE NULLS argumento do exemplo anterior.
- Se a linha anterior contiver
NULL,LAGentão a linha atual usa o valor mais recente. - Se a linha seguinte contiver um
NULLcomLEAD, então a linha atual usa o valor seguinte.
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
Exemplos: Azure Synapse Analytics
A. Compare valores entre trimestres
O exemplo seguinte demonstra a LEAD função. A consulta obtém a diferença nos valores da quota de vendas para um determinado colaborador ao longo dos trimestres civis seguintes. Como não há valor inicial disponível após a última linha, é usado o padrão zero (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;
Aqui está o conjunto de resultados.
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