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 AzureInstância Gerida do Azure SQLAzure Synapse AnalyticsSistema de Plataforma de Análise (PDW)Ponto de Extremidade 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, Azure SQL Database, Azure SQL Managed Instance, Azure SQL 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 Azure SQL 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 usam o banco de dados de exemplo AdventureWorks2025 ou AdventureWorksDW2025, que pode ser descarregado da página inicial de Exemplos e Projetos da Comunidade do Microsoft SQL Server.
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 and Analytics Platform System (PDW)
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