Comment ignorer que les n premières lignes dans la requête sql

Requête: sql-server

DECLARE @N INT = 5 --Any random number

SELECT * FROM (
        SELECT ROW_NUMBER() OVER(ORDER BY ID) AS RoNum
              , ID --Add any fields needed here (or replace ID by *)
        FROM TABLE_NAME
) AS tbl 
WHERE @N < RoNum
ORDER BY tbl.ID

Cela donnera des lignes du Tableau, où rownumber est à partir de @N + 1.

OriginalL'auteur Vikrant

SQL Server:

select * from table
except
select top N * from table

Oracle jusqu'à 11.2:

select * from table
minus
select * from table where rownum <= N

with TableWithNum as (
    select t.*, rownum as Num
    from Table t
)
select * from TableWithNum where Num > N

Oracle 12.1 et plus tard (suivant la norme ANSI SQL)

select *
from table
order by some_column 
offset x rows
fetch first y rows only

Ils peuvent répondre à vos besoins, plus ou moins.

Il n'y a aucun moyen direct de faire ce que vous voulez par SQL.
Cependant, il n'est pas un défaut de conception, à mon avis.

SQL n'est pas censé être utilisé comme cela.

Dans les bases de données relationnelles, un tableau représente une relation est un ensemble, par définition. Un ensemble contient non ordonnée d'éléments.

Aussi, ne comptez pas sur l'ordre physique des dossiers. La ligne de commande n'est pas garanti par le SGBD.

Si le classement des dossiers est importante, vous feriez mieux d'ajouter une colonne `Num' de la table et utilisez la requête suivante. Ce qui est plus naturel.

select * 
from Table 
where Num > N
order by Num

OriginalL'auteur dzhu

Voulez-vous quelque chose comme dans LINQ skip 5 et prendre 10?

SELECT TOP(10) * FROM MY_TABLE 
WHERE ID not in (SELECT TOP(5) ID From My_TABLE);

Cette approche permettra de travailler dans n'importe quel version SQL.

OriginalL'auteur Carlos Toledo

Je sais que c'est assez tard maintenant pour répondre à la requête. Mais j'ai un peu différent de la solution que les autres, qui, je crois, a de meilleures performances, car les comparaisons sont effectuées dans la requête SQL seulement le tri est fait. Vous pouvez voir ses considérable d'amélioration de la performance essentiellement lorsque la valeur du SAUT est assez GRAND.

1. Meilleure performance mais seulement pour SQL Server 2012 et au-dessus de. À l'origine de @Majid Basirati réponse qui vaut la peine de mentionner à nouveau.

   DECLARE @Skip INT = 2, @Take INT = 2
   
   SELECT * FROM TABLE_NAME
   ORDER BY ID ASC
   OFFSET (@Skip) ROWS FETCH NEXT (@Take) ROWS ONLY

2. Pas aussi Bon que le premier, mais compatible avec SQL Server 2005 et au-dessus de.

   DECLARE @Skip INT = 2, @Take INT = 2
   
   SELECT * FROM 
   (
       SELECT TOP (@Take) * FROM 
       (
           SELECT TOP (@Take + @Skip) * FROM TABLE_NAME
           ORDER BY ID ASC
       ) T1
       ORDER BY ID DESC
   ) T2
   ORDER BY ID ASC

OriginalL'auteur Khurram Hassan

Dans Faircom SQL (qui est un pseudo-MySQL), je peux le faire dans un super simple Instruction SQL, juste comme suit:

SELECT SKIP 10 * FROM TABLE ORDER BY Id

Évidemment, vous pouvez juste remplacer 10 avec toute variable déclarée de votre désir.

Je n'ai pas accès à MS SQL ou d'autres plates-formes, mais je serai vraiment surpris MS SQL ne supporte pas quelque chose comme ça.

OriginalL'auteur Ragno Croft

Pour SQL Server 2012 et les versions ultérieures, la meilleure méthode est @MajidBasirati de réponse.

J'ai aussi aimé @CarlosToledo réponse, c'est pas limité à la version de SQL Server, mais il manque des Clauses Order By. Sans eux, il peut retourner des résultats incorrects.

Pour SQL Server 2008 et plus tard je voudrais utiliser des Expressions de Table Communes pour une meilleure performance.

-- This example omits first 10 records and select next 5 records
;WITH MyCTE(Id) as
(
    SELECT TOP (10) Id 
    FROM MY_TABLE
    ORDER BY Id
)
SELECT TOP (5) * 
FROM MY_TABLE
    INNER JOIN MyCTE ON (MyCTE.Id <> MY_TABLE.Id) 
ORDER BY Id

OriginalL'auteur Jack Houston