Procura de intervalo remanescente no índice composto anulável?

Para o seguinte esquema e dados de exemplo

CREATE TABLE T
  (
     A INT NULL,
     B INT NOT NULL IDENTITY,
     C CHAR(8000) NULL,
     UNIQUE CLUSTERED (A, B)
  )

INSERT INTO T
            (A)
SELECT NULLIF(( ( ROW_NUMBER() OVER (ORDER BY @@SPID) - 1 ) / 1003 ), 0)
FROM   master..spt_values 

Um aplicativo está processando as linhas desta tabela em ordem de índice clusterizado em 1.000 pedaços de linha.

As primeiras 1.000 linhas são recuperadas da consulta a seguir.

SELECT TOP 1000 *
FROM   T
ORDER  BY A, B 

A linha final desse conjunto está abaixo

+------+------+
|  A   |  B   |
+------+------+
| NULL | 1000 |
+------+------+

Existe alguma maneira de escrever uma consulta que apenas busque nessa chave de índice composta e a siga para recuperar o próximo pedaço de 1000 linhas?

/*Pseudo Syntax*/
SELECT TOP 1000 *
FROM   T
WHERE (A, B) is_ordered_after (@A, @B)
ORDER  BY A, B 

O menor número de leituras que consegui chegar até agora é 1020, mas a consulta parece complicada demais. Existe uma maneira mais simples de igual ou melhor eficiência? Talvez alguém que consiga fazer tudo de uma só vez procure?

DECLARE @A INT = NULL, @B INT = 1000

;WITH UnProcessed
     AS (SELECT *
         FROM   T
         WHERE  ( EXISTS(SELECT A
                         INTERSECT
                         SELECT @A)
                  AND B > @B )
         UNION ALL
         SELECT *
         FROM   T
         WHERE @A IS NULL AND A IS NOT NULL
         UNION ALL
         SELECT *
         FROM   T
         WHERE A > @A        
         )
SELECT TOP 1000 *
FROM   UnProcessed
ORDER  BY A,
          B 

FWIW: Se a coluna Afor criada NOT NULLe um valor sentinela -1for usado, o plano de execução equivalente certamente parecerá mais simples

Mas o operador de busca única no plano ainda realiza duas buscas vez de reduzi-las em um único intervalo contíguo e as leituras lógicas são as mesmas, então eu suspeito que talvez isso seja tão bom quanto possível?

Existe alguma maneira de escrever uma consulta que apenas busque nessa chave de índice composta e a siga para recuperar o próximo pedaço de 1000 linhas?

Uma das minhas soluções favoritas é usar um APIcursor:

SET NOCOUNT ON;
SET STATISTICS IO ON;

DECLARE 
    @cur integer,
    -- FAST_FORWARD, AUTO_FETCH, AUTO_CLOSE, CHECK_ACCEPTED_TYPES, FAST_FORWARD_ACCEPTABLE
    @scrollopt integer = 16 | 8192 | 16384 | 32768 | 1048576,
    -- READ_ONLY, CHECK_ACCEPTED_OPTS, READ_ONLY_ACCEPTABLE
    @ccopt integer = 1 | 32768 | 65536, 
    @rowcount integer = 1000,
    @rc integer;

-- Open the cursor and return (up to) the first 1000 rows
EXECUTE @rc = sys.sp_cursoropen
    @cur OUTPUT,
    N'
    SELECT A, B, C
    FROM T
    ORDER BY A, B;
    ',
    @scrollopt OUTPUT,
    @ccopt OUTPUT,
    @rowcount OUTPUT;

IF @rc <> 16 -- FastForward cursor automatically closed
BEGIN
    -- Name the cursor so we can use CURSOR_STATUS
    EXECUTE sys.sp_cursoroption
        @cur, 
        2, 
        'MyCursorName';

    -- Until the cursor auto-closes
    WHILE CURSOR_STATUS('global', 'MyCursorName') = 1
    BEGIN
        EXECUTE sys.sp_cursorfetch
            @cur,
            2,
            0,
            1000;
    END;
END;

SET STATISTICS IO OFF;

A estratégia geral é uma única verificação que lembra sua posição entre as chamadas. Usar um APIcursor significa que podemos retornar um bloco de linhas em vez de um de cada vez, como seria o caso de um T-SQLcursor:

A STATISTICS IOsaída é:

Table 'T'. Scan count 1, logical reads 1011, physical reads 0, read-ahead reads 0
Table 'T'. Scan count 1, logical reads 1001, physical reads 0, read-ahead reads 0
Table 'T'. Scan count 1, logical reads 516, physical reads 0, read-ahead reads 0