Wie wähle ich die n-te Zeile in einer SQL-Datenbanktabelle aus?

Ich bin daran interessiert, einige (idealerweise) datenbankunabhängige Methoden zur Auswahl der n- ten Zeile aus einer Datenbanktabelle zu lernen . Es wäre auch interessant zu sehen, wie dies mit der nativen Funktionalität der folgenden Datenbanken erreicht werden kann:

• SQL Server
• MySQL
• PostgreSQL
• SQLite
• Orakel

Ich mache derzeit in SQL Server 2005 so etwas wie das Folgende, aber ich wäre daran interessiert, die agnostischeren Ansätze anderer zu sehen:

WITH Ordered AS (
SELECT ROW_NUMBER() OVER (ORDER BY OrderID) AS RowNumber, OrderID, OrderDate
FROM Orders)
SELECT *
FROM Ordered
WHERE RowNumber = 1000000

Gutschrift für das oben genannte SQL: Firoz Ansaris Weblog

Update: Siehe Troels Arvins Antwort zum SQL-Standard. Troels, hast du irgendwelche Links, die wir zitieren können?

Es gibt Möglichkeiten, dies in optionalen Teilen des Standards zu tun, aber viele Datenbanken unterstützen ihre eigene Vorgehensweise.

Eine wirklich gute Seite, die über dieses und andere Dinge spricht, ist http://troels.arvin.dk/db/rdbms/#select-limit .

Grundsätzlich unterstützen PostgreSQL und MySQL das Nicht-Standard:

SELECT...
LIMIT y OFFSET x 

Oracle, DB2 und MSSQL unterstützen die Standardfensterfunktionen:

SELECT * FROM (
  SELECT
    ROW_NUMBER() OVER (ORDER BY key ASC) AS rownumber,
    columns
  FROM tablename
) AS foo
WHERE rownumber <= n

(die ich gerade von der oben verlinkten Seite kopiert habe, da ich diese DBs nie benutze)

Update: Ab PostgreSQL 8.4 werden die Standardfensterfunktionen unterstützt. Erwarten Sie daher, dass das zweite Beispiel auch für PostgreSQL funktioniert.

Update: SQLite hat am 15.09.2018 Unterstützung für Fensterfunktionen in Version 3.25.0 hinzugefügt, sodass beide Formulare auch in SQLite funktionieren.

PostgreSQL unterstützt Fensterfunktionen, wie sie im SQL-Standard definiert sind, aber sie sind umständlich, sodass die meisten Benutzer (den Nicht-Standard) LIMIT/ verwendenOFFSET :

SELECT
    *
FROM
    mytable
ORDER BY
    somefield
LIMIT 1 OFFSET 20;

In diesem Beispiel wird die 21. Zeile ausgewählt. OFFSET 20fordert Postgres auf, die ersten 20 Datensätze zu überspringen. Wenn Sie keine ORDER BYKlausel angeben , gibt es keine Garantie dafür, welchen Datensatz Sie zurückerhalten, was selten nützlich ist.

Ich bin mir über den Rest nicht sicher, aber ich weiß, dass SQLite und MySQL keine "Standard" -Zeilenreihenfolge haben. Zumindest in diesen beiden Dialekten erfasst das folgende Snippet den 15. Eintrag aus der Tabelle und sortiert nach dem Datum / der Uhrzeit, zu der es hinzugefügt wurde:

SELECT * FROM the_table ORDER BY added DESC LIMIT 1,15

(Natürlich müssten Sie ein DATETIME-Feld hinzufügen und es auf das Datum / die Uhrzeit einstellen, zu der der Eintrag hinzugefügt wurde ...)

In SQL 2005 und höher ist diese Funktion integriert. Verwenden Sie die Funktion ROW_NUMBER (). Es eignet sich hervorragend für Webseiten mit einem Browsing im Stil << Zurück und Weiter >>:

Syntax:

SELECT
    *
FROM
    (
        SELECT
            ROW_NUMBER () OVER (ORDER BY MyColumnToOrderBy) AS RowNum,
            *
        FROM
            Table_1
    ) sub
WHERE
    RowNum = 23

Ich vermute, dass dies äußerst ineffizient ist, aber ein recht einfacher Ansatz ist, der an einem kleinen Datensatz funktioniert hat, an dem ich ihn ausprobiert habe.

select top 1 field
from table
where field in (select top 5 field from table order by field asc)
order by field desc

Dies würde den 5. Artikel erhalten, die zweite Top-Nummer ändern, um einen anderen n-ten Artikel zu erhalten

Nur SQL Server (glaube ich), sollte aber auf älteren Versionen funktionieren, die ROW_NUMBER () nicht unterstützen.

1 kleine Änderung: n-1 statt n.

select *
from thetable
limit n-1, 1

Überprüfen Sie es auf SQL Server:

Select top 10 * From emp 
EXCEPT
Select top 9 * From emp

Dies gibt Ihnen die 10. REIHE der Emp-Tabelle!

Im Gegensatz zu einigen Antworten schweigt der SQL-Standard zu diesem Thema nicht.

Seit SQL: 2003 können Sie "Fensterfunktionen" verwenden, um Zeilen zu überspringen und Ergebnismengen einzuschränken.

In SQL: 2008 wurde ein etwas einfacherer Ansatz hinzugefügt
OFFSET skip ROWS FETCH FIRST n ROWS ONLY

Persönlich glaube ich nicht, dass die Hinzufügung von SQL: 2008 wirklich notwendig war. Wenn ich also ISO wäre, hätte ich es aus einem bereits ziemlich großen Standard herausgehalten.

Als wir in MSSQL 2000 gearbeitet haben, haben wir das gemacht, was wir "Triple-Flip" genannt haben:

BEARBEITET

DECLARE @InnerPageSize int
DECLARE @OuterPageSize int
DECLARE @Count int

SELECT @Count = COUNT(<column>) FROM <TABLE>
SET @InnerPageSize = @PageNum * @PageSize
SET @OuterPageSize = @Count - ((@PageNum - 1) * @PageSize)

IF (@OuterPageSize < 0)
    SET @OuterPageSize = 0
ELSE IF (@OuterPageSize > @PageSize)
    SET @OuterPageSize = @PageSize

DECLARE @sql NVARCHAR(8000)

SET @sql = 'SELECT * FROM
(
    SELECT TOP ' + CAST(@OuterPageSize AS nvarchar(5)) + ' * FROM
    (
        SELECT TOP ' + CAST(@InnerPageSize AS nvarchar(5)) + ' * FROM <TABLE> ORDER BY <column> ASC
    ) AS t1 ORDER BY <column> DESC
) AS t2 ORDER BY <column> ASC'

PRINT @sql
EXECUTE sp_executesql @sql

Es war nicht elegant und nicht schnell, aber es funktionierte.

SQL SERVER

Wählen Sie den n-ten Datensatz von oben aus

SELECT * FROM (
SELECT 
ID, NAME, ROW_NUMBER() OVER(ORDER BY ID) AS ROW
FROM TABLE 
) AS TMP 
WHERE ROW = n

Wählen Sie den n-ten Datensatz von unten aus

SELECT * FROM (
SELECT 
ID, NAME, ROW_NUMBER() OVER(ORDER BY ID DESC) AS ROW
FROM TABLE 
) AS TMP 
WHERE ROW = n

Orakel:

select * from (select foo from bar order by foo) where ROWNUM = x

In Oracle 12c können Sie die OFFSET..FETCH..ROWS Option mit verwendenORDER BY

Zum Beispiel, um den 3. Datensatz von oben zu erhalten:

SELECT * 
FROM   sometable
ORDER BY column_name
OFFSET 2 ROWS FETCH NEXT 1 ROWS ONLY;

Hier ist eine schnelle Lösung Ihrer Verwirrung.

SELECT * FROM table ORDER BY `id` DESC LIMIT N, 1

Hier können Sie die letzte Zeile durch Füllen von N = 0, die vorletzte durch N = 1, die vierte letzte durch Füllen von N = 3 usw. erhalten.

Dies ist eine sehr häufige Frage während des Interviews und dies ist eine sehr einfache Antwort darauf.

Weiter Wenn Sie Betrag, ID oder eine numerische Sortierreihenfolge wünschen, können Sie sich für die CAST-Funktion in MySQL entscheiden.

SELECT DISTINCT (`amount`) FROM cart ORDER BY CAST( `amount` AS SIGNED ) DESC LIMIT 4 , 1

Hier Durch Ausfüllen von N = 4 können Sie die fünftletzte Aufzeichnung der höchsten Menge aus der CART-Tabelle erhalten. Sie können Ihren Feld- und Tabellennamen anpassen und eine Lösung finden.

HINZUFÜGEN:

LIMIT n,1

Dadurch werden die Ergebnisse ab Ergebnis n auf ein Ergebnis begrenzt.

Wenn Sie beispielsweise jede 10. Zeile in MSSQL auswählen möchten, können Sie Folgendes verwenden:

SELECT * FROM (
  SELECT
    ROW_NUMBER() OVER (ORDER BY ColumnName1 ASC) AS rownumber, ColumnName1, ColumnName2
  FROM TableName
) AS foo
WHERE rownumber % 10 = 0

Nehmen Sie einfach den MOD und ändern Sie hier die Nummer 10 nach Belieben.

Für SQL Server ist ein generischer Weg, nach Zeilennummer zu gehen, wie folgt:

SET ROWCOUNT @row --@row = the row number you wish to work on.

Zum Beispiel:

set rowcount 20   --sets row to 20th row

select meat, cheese from dbo.sandwich --select columns from table at 20th row

set rowcount 0   --sets rowcount back to all rows

Dies gibt die Informationen der 20. Zeile zurück. Stellen Sie sicher, dass Sie danach die Zeilenanzahl 0 eingeben.

LIMIT n, 1 funktioniert in MS SQL Server nicht. Ich denke, es ist nur die einzige große Datenbank, die diese Syntax nicht unterstützt. Um fair zu sein, ist es nicht Teil des SQL-Standards, obwohl es so weit verbreitet ist, dass es sein sollte. In allem außer SQL Server funktioniert LIMIT hervorragend. Für SQL Server konnte ich keine elegante Lösung finden.

Hier ist eine generische Version eines Sproc, den ich kürzlich für Oracle geschrieben habe und der dynamisches Paging / Sortieren ermöglicht - HTH

-- p_LowerBound = first row # in the returned set; if second page of 10 rows,
--                this would be 11 (-1 for unbounded/not set)
-- p_UpperBound = last row # in the returned set; if second page of 10 rows,
--                this would be 20 (-1 for unbounded/not set)

OPEN o_Cursor FOR
SELECT * FROM (
SELECT
    Column1,
    Column2
    rownum AS rn
FROM
(
    SELECT
        tbl.Column1,
        tbl.column2
    FROM MyTable tbl
    WHERE
        tbl.Column1 = p_PKParam OR
        tbl.Column1 = -1
    ORDER BY
        DECODE(p_sortOrder, 'A', DECODE(p_sortColumn, 1, Column1, 'X'),'X'),
        DECODE(p_sortOrder, 'D', DECODE(p_sortColumn, 1, Column1, 'X'),'X') DESC,
        DECODE(p_sortOrder, 'A', DECODE(p_sortColumn, 2, Column2, sysdate),sysdate),
        DECODE(p_sortOrder, 'D', DECODE(p_sortColumn, 2, Column2, sysdate),sysdate) DESC
))
WHERE
    (rn >= p_lowerBound OR p_lowerBound = -1) AND
    (rn <= p_upperBound OR p_upperBound = -1);

Aber wirklich, ist das nicht wirklich nur ein Salon-Trick für ein gutes Datenbankdesign? Die wenigen Male, die ich solche Funktionen benötigte, war es für eine einfache einmalige Abfrage, einen schnellen Bericht zu erstellen. Für jede echte Arbeit führt die Verwendung solcher Tricks zu Problemen. Wenn die Auswahl einer bestimmten Zeile erforderlich ist, haben Sie einfach eine Spalte mit einem sequentiellen Wert und fertig.

Für SQL Server wird im Folgenden die erste Zeile aus der angegebenen Tabelle zurückgegeben.

declare @rowNumber int = 1;
    select TOP(@rowNumber) * from [dbo].[someTable];
EXCEPT
    select TOP(@rowNumber - 1) * from [dbo].[someTable];

Sie können die Werte folgendermaßen durchlaufen:

WHILE @constVar > 0
BEGIN
    declare @rowNumber int = @consVar;
       select TOP(@rowNumber) * from [dbo].[someTable];
    EXCEPT
       select TOP(@rowNumber - 1) * from [dbo].[someTable];  

       SET @constVar = @constVar - 1;    
END;

In Sybase SQL Anywhere:

SELECT TOP 1 START AT n * from table ORDER BY whatever

Vergessen Sie nicht die Bestellung von oder es ist bedeutungslos.

T-SQL - Auswahl der N-ten Datensatznummer aus einer Tabelle

select * from
 (select row_number() over (order by Rand() desc) as Rno,* from TableName) T where T.Rno = RecordNumber

Where  RecordNumber --> Record Number to Select
       TableName --> To be Replaced with your Table Name

Um beispielsweise den 5. Datensatz aus einer Tabelle Mitarbeiter auszuwählen, sollte Ihre Abfrage lauten

select * from
 (select row_number() over (order by Rand() desc) as Rno,* from Employee) T where T.Rno = 5

SELECT * FROM emp a
WHERE  n = (SELECT COUNT( _rowid)
              FROM emp b
             WHERE a. _rowid >= b. _rowid);

SELECT
    top 1 *
FROM
    table_name
WHERE
    column_name IN (
        SELECT
            top N column_name
        FROM
            TABLE
        ORDER BY
            column_name
    )
ORDER BY
    column_name DESC

Ich habe diese Abfrage geschrieben, um die N-te Zeile zu finden. Beispiel mit dieser Abfrage wäre

SELECT
    top 1 *
FROM
    Employee
WHERE
    emp_id IN (
        SELECT
            top 7 emp_id
        FROM
            Employee
        ORDER BY
            emp_id
    )
ORDER BY
    emp_id DESC

Es ist unglaublich, dass Sie eine SQL-Engine finden, die diese ausführt ...

WITH sentence AS
(SELECT 
    stuff,
    row = ROW_NUMBER() OVER (ORDER BY Id)
FROM 
    SentenceType
    )
SELECT
    sen.stuff
FROM sentence sen
WHERE sen.row = (ABS(CHECKSUM(NEWID())) % 100) + 1

Nichts Besonderes, keine besonderen Funktionen, falls Sie Caché wie ich verwenden ...

SELECT TOP 1 * FROM (
  SELECT TOP n * FROM <table>
  ORDER BY ID Desc
)
ORDER BY ID ASC

Vorausgesetzt, Sie haben eine ID-Spalte oder eine Datenstempelspalte, der Sie vertrauen können.

So würde ich es in DB2 SQL machen. Ich glaube, die RRN (relative Datensatznummer) wird vom Betriebssystem in der Tabelle gespeichert.

SELECT * FROM (                        
   SELECT RRN(FOO) AS RRN, FOO.*
   FROM FOO                         
   ORDER BY RRN(FOO)) BAR             
 WHERE BAR.RRN = recordnumber

select * from 
(select * from ordered order by order_id limit 100) x order by 
x.order_id desc limit 1;

Wählen Sie zuerst die obersten 100 Zeilen in aufsteigender Reihenfolge und dann die letzte Zeile in absteigender Reihenfolge und begrenzen Sie sie auf 1. Dies ist jedoch eine sehr teure Aussage, da zweimal auf die Daten zugegriffen wird.

Es scheint mir, dass Sie, um effizient zu sein, 1) eine Zufallszahl zwischen 0 und eins weniger als die Anzahl der Datenbankeinträge generieren müssen und 2) die Zeile an dieser Position auswählen können. Leider haben verschiedene Datenbanken unterschiedliche Zufallszahlengeneratoren und unterschiedliche Möglichkeiten, eine Zeile an einer Position in einer Ergebnismenge auszuwählen. Normalerweise geben Sie an, wie viele Zeilen übersprungen werden sollen und wie viele Zeilen Sie möchten. Für verschiedene Datenbanken wird dies jedoch unterschiedlich ausgeführt. Hier ist etwas, das für mich in SQLite funktioniert:

select * 
from Table 
limit abs(random()) % (select count(*) from Words), 1;

Es hängt davon ab, ob eine Unterabfrage in der Limit-Klausel verwendet werden kann (in SQLite LIMIT <zu überspringende Recs>, <zu nehmende Recs>). Die Auswahl der Anzahl der Datensätze in einer Tabelle sollte besonders effizient sein und Teil der Datenbank sein Metadaten, aber das hängt von der Implementierung der Datenbank ab. Ich weiß auch nicht, ob die Abfrage tatsächlich die Ergebnismenge erstellt, bevor der N-te Datensatz abgerufen wird, aber ich würde hoffen, dass dies nicht erforderlich ist. Beachten Sie, dass ich keine "order by" -Klausel spezifiziere. Es ist möglicherweise besser, nach dem Primärschlüssel zu "ordnen", der einen Index enthält. Das Abrufen des N-ten Datensatzes aus einem Index ist möglicherweise schneller, wenn die Datenbank den N-ten Datensatz nicht aus der Datenbank selbst abrufen kann, ohne die Ergebnismenge zu erstellen .

Die am besten geeignete Antwort, die ich in diesem Artikel für SQL Server gesehen habe

WITH myTableWithRows AS (
    SELECT (ROW_NUMBER() OVER (ORDER BY myTable.SomeField)) as row,*
    FROM myTable)
SELECT * FROM myTableWithRows WHERE row = 3