Equivalente a LIMIT para DB2

Como você se sai LIMITno DB2 para iSeries?

Tenho uma tabela com mais de 50.000 registros e desejo retornar os registros de 0 a 10.000 e os registros de 10.000 a 20.000.

Eu sei que no SQL você escreve LIMIT 0,10000no final da consulta de 0 a 10.000 e LIMIT 10000,10000no final da consulta de 10.000 a 20.000

Então, como isso é feito no DB2? Qual é o código e a sintaxe? (exemplo de consulta completo é apreciado)

Usando FETCH FIRST [n] ROWS ONLY:

http://publib.boulder.ibm.com/infocenter/dzichelp/v2r2/index.jsp?topic=/com.ibm.db29.doc.perf/db2z_fetchfirstnrows.htm

SELECT LASTNAME, FIRSTNAME, EMPNO, SALARY
  FROM EMP
  ORDER BY SALARY DESC
  FETCH FIRST 20 ROWS ONLY;

Para obter intervalos, você teria que usar ROW_NUMBER()(desde a v5r4) e usar isso dentro da WHEREcláusula: (roubado daqui: http://www.justskins.com/forums/db2-select-how-to-123209.html )

SELECT code, name, address
FROM ( 
  SELECT row_number() OVER ( ORDER BY code ) AS rid, code, name, address
  FROM contacts
  WHERE name LIKE '%Bob%' 
  ) AS t
WHERE t.rid BETWEEN 20 AND 25;

Desenvolvido este método:

Você PRECISA de uma tabela que tenha um valor exclusivo que possa ser solicitado.

Se você deseja linhas de 10.000 a 25.000 e sua Tabela tem 40.000 linhas, primeiro você precisa obter o ponto inicial e o total de linhas:

int start = 40000 - 10000;

int total = 25000 - 10000;

Em seguida, passe-os por código para a consulta:

SELECT * FROM 
(SELECT * FROM schema.mytable 
ORDER BY userId DESC fetch first {start} rows only ) AS mini 
ORDER BY mini.userId ASC fetch first {total} rows only

O suporte para OFFSET e LIMIT foi adicionado recentemente ao DB2 para i 7.1 e 7.2. Você precisa dos seguintes níveis de grupo DB PTF para obter este suporte:

• SF99702 nível 9 para IBM i 7.2
• SF99701 nível 38 para IBM i 7.1

Consulte aqui para obter mais informações: documentação OFFSET e LIMIT , DB2 for i Enhancement Wiki

Esta é a solução que encontrei:

select FIELD from TABLE where FIELD > LASTVAL order by FIELD fetch first N rows only;

Inicializando LASTVAL para 0 (ou '' para um campo de texto) e, em seguida, definindo-o como o último valor no conjunto de registros mais recente, isso percorrerá a tabela em blocos de N registros.

A solução de @elcool é uma ideia inteligente, mas você precisa saber o número total de linhas (que pode até mudar enquanto você executa a consulta!). Portanto, proponho uma versão modificada, que infelizmente precisa de 3 subconsultas em vez de 2:

select * from (
    select * from (
        select * from MYLIB.MYTABLE
        order by MYID asc 
        fetch first {last} rows only 
        ) I 
    order by MYID desc
    fetch first {length} rows only
    ) II
order by MYID asc

onde {last}deve ser substituído pelo número da linha do último registro que preciso e {length}deve ser substituído pelo número de linhas que preciso, calculado como last row - first row + 1.

Por exemplo, se eu quiser linhas de 10 a 25 (no total 16 linhas), {last}serei 25 e {length}25-10 + 1 = 16.

Você também deve considerar a cláusula OPTIMIZE FOR n ROWS. Mais detalhes sobre tudo isso na documentação do DB2 LUW no tópico Diretrizes para restringir instruções SELECT :

• A cláusula OPTIMIZE FOR declara a intenção de recuperar apenas um subconjunto do resultado ou de dar prioridade à recuperação apenas das primeiras linhas. O otimizador pode então escolher planos de acesso que minimizam o tempo de resposta para recuperar as primeiras linhas.

Tente isto

SELECT * FROM
    (
        SELECT T.*, ROW_NUMBER() OVER() R FROM TABLE T
    )
    WHERE R BETWEEN 10000 AND 20000

Existem 2 soluções para paginar com eficiência em uma tabela do DB2:

1 - a técnica usando a função número_da_linha () e a cláusula OVER que foi apresentada em outro post ("SELECT número_da_linha () OVER (ORDER BY ...)"). Em algumas mesas grandes, percebi às vezes uma degradação do desempenho.

2 - a técnica usando um cursor de rolagem. A implementação depende da linguagem utilizada. Essa técnica parece mais robusta em grandes mesas.

Apresentei as 2 técnicas implementadas em PHP durante um seminário no próximo ano. O slide está disponível neste link: http://gregphplab.com/serendipity/uploads/slides/DB2_PHP_Best_practices.pdf

Desculpe, mas este documento está apenas em francês.

Existem estas opções disponíveis: -

DB2 has several strategies to cope with this problem.
You can use the "scrollable cursor" in feature.
In this case you can open a cursor and, instead of re-issuing a query you can FETCH forward and backward.
This works great if your application can hold state since it doesn't require DB2 to rerun the query every time.
You can use the ROW_NUMBER() OLAP function to number rows and then return the subset you want.
This is ANSI SQL 
You can use the ROWNUM pseudo columns which does the same as ROW_NUMBER() but is suitable if you have Oracle skills.
You can use LIMIT and OFFSET if you are more leaning to a mySQL or PostgreSQL dialect.