Mysql-Sortierung und Paginierung (Order by & Limit) und vorhandene Fallstricke

Mysql-Sortierung und Paginierung (Order by & Limit) und vorhandene Fallstricke

Sortierabfrage (Sortieren nach)

Im E-Commerce: Wir möchten alle heute abgeschlossenen Bestellungen anzeigen und sie nach Transaktionsbetrag von hoch nach niedrig sortieren. Zu diesem Zeitpunkt können wir die Sortierfunktion in der Datenbank verwenden, um dies abzuschließen.

Sortiersyntax:

Wähle den Feldnamen aus der Tabellennamensortierung nach Feld1 [aufsteigend|absteigend], Feld2 [aufsteigend|absteigend];
  • Die zu sortierenden Felder folgen der Reihenfolge nach;
  • asc|desc gibt die Sortierregel an, asc: aufsteigende Reihenfolge, desc: absteigende Reihenfolge, der Standard ist asc;
  • Unterstützt das Sortieren nach mehreren Feldern und mehrere Felder werden durch Kommas getrennt.

Einzelfeldsortierung

mysql> Tabelle erstellen test2(a int,b varchar(10));
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)
mysql> in Test2-Werte einfügen (10, 'Jack'), (8, 'Tom'), (5, 'bereit'), (100, 'Javacode');
Abfrage OK, 4 Zeilen betroffen (0,00 Sek.)
Datensätze: 4 Duplikate: 0 Warnungen: 0
mysql> wähle * aus test2;
+------+----------+
| ein | b |
+------+----------+
| 10 | Buchse |
| 8 | tom |
| 5 | bereit |
| 100 | Javacode |
+------+----------+
4 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus Test2, sortiere nach a aufsteigend;
+------+----------+
| ein | b |
+------+----------+
| 5 | bereit |
| 8 | tom |
| 10 | Buchse |
| 100 | Javacode |
+------+----------+
4 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus Test2, sortiert nach einem absteigenden;
+------+----------+
| ein | b |
+------+----------+
| 100 | Javacode |
| 10 | Buchse |
| 8 | tom |
| 5 | bereit |
+------+----------+
4 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus test2, sortiert nach a;
+------+----------+
| ein | b |
+------+----------+
| 5 | bereit |
| 8 | tom |
| 10 | Buchse |
| 100 | Javacode |
+------+----------+
4 Zeilen im Satz (0,00 Sek.)

Sortieren mehrerer Felder

Sortieren Sie beispielsweise in der Studententabelle zuerst nach dem Alter der Studenten in absteigender Reihenfolge und dann, wenn das Alter gleich ist, nach der Studenten-ID in aufsteigender Reihenfolge, wie folgt:

mysql> Tabelle erstellen stu(id int nicht null Kommentar 'Matrikelnummer' Primärschlüssel, Alter tinyint nicht null Kommentar 'Alter', Name varchar(16) Kommentar 'Name');
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)
mysql> in stu (id, age, name)-Werte einfügen (1001,18, „Java-Fehler beheben“, (1005,20, „Fehler beheben“, (1003,18, „Fehler beheben“, (1004,20, „Fehler beheben“, (1010,19, „Fehler beheben“);
Abfrage OK, 5 Zeilen betroffen (0,00 Sek.)
Datensätze: 5 Duplikate: 0 Warnungen: 0
mysql> wähle * von stu;
+------+-----+--------------+
| ID | Alter | Name |
+------+-----+--------------+
| 1001 | 18 | Passant Java |
| 1003 | 18 | Jacky Cheung |
| 1004 | 20 | Leslie Cheung |
| 1005 | 20 | Andy Lau |
| 1010 | 19 | Tony Leung Chiu Wai |
+------+-----+--------------+
5 Zeilen im Satz (0,00 Sek.)
mysql> Auswahl * von stu, Sortierung nach Alter absteigend, ID aufsteigend;
+------+-----+--------------+
| ID | Alter | Name |
+------+-----+--------------+
| 1004 | 20 | Leslie Cheung |
| 1005 | 20 | Andy Lau |
| 1010 | 19 | Tony Leung Chiu Wai |
| 1001 | 18 | Passant Java |
| 1003 | 18 | Jacky Cheung |
+------+-----+--------------+
5 Zeilen im Satz (0,00 Sek.)

Nach Alias ​​sortieren

mysql> wähle * von stu;
+------+-----+--------------+
| ID | Alter | Name |
+------+-----+--------------+
| 1001 | 18 | Passant Java |
| 1003 | 18 | Jacky Cheung |
| 1004 | 20 | Leslie Cheung |
| 1005 | 20 | Andy Lau |
| 1010 | 19 | Tony Leung Chiu Wai |
+------+-----+--------------+
5 Zeilen im Satz (0,00 Sek.)
mysql> wähle Alter „Alter“, ID als „Matrikelnummer“ aus Stu, sortiert nach Alter aufsteigend, Matrikelnummer absteigend;
+--------+--------+
| Alter| Studierendenausweis|
+--------+--------+
| 18 | 1003 |
| 18 | 1001 |
| 19 | 1010 |
| 20 | 1005 |
| 20 | 1004 |
+--------+--------+

Sortieren nach Funktion

Es gibt eine Studententabelle (ID: Nummer, Geburt: Geburtsdatum, Name: Name), wie folgt:

mysql> Tabelle löschen, falls Student vorhanden;
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)
mysql> CREATE TABLE student (
  -> id int(11) NOT NULL COMMENT 'Matrikelnummer',
  -> Geburtsdatum NOT NULL KOMMENTAR 'Geburtsdatum',
  -> Name varchar (16) DEFAULT NULL COMMENT 'Name',
  -> PRIMÄRSCHLÜSSEL (id)
  -> );
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)
mysql> in Schülerwerte (ID, Geburtsdatum, Name) einfügen (1001, '10.10.1990', 'Passerby Java'), (1005, '01.03.1960', 'Andy Lau'), (1003, '16.08.1960', 'Jacky Cheung'), (1004, '01.07.1968', 'Leslie Cheung'), (1010, '16.05.1962', 'Tony Leung');
Abfrage OK, 5 Zeilen betroffen (0,00 Sek.)
Datensätze: 5 Duplikate: 0 Warnungen: 0
MySQL>
mysql> AUSWÄHLEN * VON Student;
+------+------------+------------------+
| ID | Geburt | Name |
+------+------------+------------------+
| 1001 | 10.10.1990 | Passant Java |
| 1003 | 16.08.1960 | Jacky Cheung |
| 1004 | 01.07.1968 | Leslie Cheung |
| 1005 | 01.03.1960 | Andy Lau |
| 1010 | 16.05.1962 | Tony Leung Chiu Wai |
+------+------------+------------------+
5 Zeilen im Satz (0,00 Sek.)

Anforderung: Abfrage von Nummer, Geburtsdatum, Geburtsjahr und Name in aufsteigender Reihenfolge von Geburtsjahr und Nummer. Es gibt zwei Möglichkeiten, sie wie folgt zu schreiben:

mysql> SELECT ID-Nummer, Geburtsdatum, Geburtsjahr (Geburt) Geburtsjahr, Name Name des Schülers ORDER BY Jahr (Geburt) asc, ID asc;
+--------+--------------+--------------+---------------+
| Nummer| Geburtsdatum| Geburtsjahr| Name|
+--------+--------------+--------------+---------------+
| 1003 | 16.08.1960 | 1960 | Jacky Cheung |
| 1005 | 01.03.1960 | 1960 | Andy Lau |
| 1010 | 16.05.1962 | 1962 | Tony Leung Chiu Wai |
| 1004 | 01.07.1968 | 1968 | Leslie Cheung |
| 1001 | 10.10.1990 | 1990 | Passant Java |
+--------+--------------+--------------+---------------+
5 Zeilen im Satz (0,00 Sek.)
mysql> SELECT ID-Nummer, Geburtsdatum, Jahr (Geburt), Geburtsjahr, Name, Name des Schülers, ORDER BY Geburtsjahr aufsteigend, ID aufsteigend;
+--------+--------------+--------------+---------------+
| Nummer| Geburtsdatum| Geburtsjahr| Name|
+--------+--------------+--------------+---------------+
| 1003 | 16.08.1960 | 1960 | Jacky Cheung |
| 1005 | 01.03.1960 | 1960 | Andy Lau |
| 1010 | 16.05.1962 | 1962 | Tony Leung Chiu Wai |
| 1004 | 01.07.1968 | 1968 | Leslie Cheung |
| 1001 | 10.10.1990 | 1990 | Passant Java |
+--------+--------------+--------------+---------------+
5 Zeilen im Satz (0,00 Sek.)

veranschaulichen:
Jahresfunktion: Dies ist eine Datumsfunktion, die das Jahr im entsprechenden Datum abrufen kann.
Oben gibt es zwei Sortiermethoden. Die erste besteht in der Verwendung einer Funktion in „Order by“, die zweite in der Verwendung einer Alias-Sortierung.

Sortieren nach wo

Die Bestelldaten lauten wie folgt:

mysql> Tabelle löschen, falls vorhanden, t_order;
Abfrage OK, 0 Zeilen betroffen, 1 Warnung (0,00 Sek.)
mysql> Tabelle t_order erstellen(
  -> id int nicht null auto_increment Kommentar 'Bestellnummer',
  -> Preis Dezimalzahl (10,2) nicht null Standard 0 Kommentar 'Bestellmenge',
  -> Primärschlüssel (ID)
  ->)Kommentar 'Bestelltabelle';
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)
mysql> in t_order (Preis) Werte (88,95), (100,68), (500), (300), (20,88), (200,5) einfügen;
Abfrage OK, 6 Zeilen betroffen (0,00 Sek.)
Datensätze: 6 Duplikate: 0 Warnungen: 0
mysql> wähle * aus t_order;
+----+--------+
| ID | Preis |
+----+--------+
| 1 | 88,95 |
| 2 | 100,68 |
| 3 | 500,00 |
| 4 | 300,00 |
| 5 | 20,88 |
| 6 | 200,50 |
+----+--------+
6 Zeilen im Satz (0,00 Sek.)

Anforderung: Abfrage des Bestellbetrags >= 100, Sortierung nach Bestellbetrag in absteigender Reihenfolge und Anzeige von 2 Datenspalten, Spaltenüberschriften: Bestellnummer, Bestellbetrag, wie folgt:

mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order a, wobei a.price>=100 sortiert nach a.price desc;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 3 | 500,00 |
| 4 | 300,00 |
| 6 | 200,50 |
| 2 | 100,68 |
+--------------+--------------+
4 Zeilen im Satz (0,00 Sek.)

Limit-Einführung

Mit „Limit“ wird die Anzahl der von einer Auswahlabfrage zurückgegebenen Zeilen begrenzt und wird häufig für Vorgänge wie die Seitennummerierung verwendet.

Grammatik:

Spalte aus Tabellenlimit [Offset,] Anzahl auswählen;

veranschaulichen:

  • Offset: stellt den Offset dar, also in Laiensprache, wie viele Zeilen übersprungen werden sollen. Offset kann weggelassen werden und ist standardmäßig 0, was bedeutet, dass 0 Zeilen übersprungen werden. Bereich: [0, +∞).
  • Anzahl: Überspringen Sie die Offsetzeile und beginnen Sie mit dem Abrufen der Daten, wobei die Anzahl der Datensatzzeilen abgerufen wird; Bereich: [0, +∞).
  • Die Werte von Offset und Anzahl im Limit können keine Ausdrücke verwenden.

Nachfolgend führen wir einige häufig verwendete Beispiele auf, um Ihr Verständnis zu vertiefen.

Holen Sie sich die ersten n Zeilen der Datensätze

Spalten aus Tabellenlimit 0,n auswählen;
Oder wählen Sie Spalten aus der Tabellengrenze n aus;

So erhalten Sie beispielsweise die ersten beiden Datensätze einer Bestellung:

mysql> Tabelle t_order erstellen(
  -> id int nicht null auto_increment Kommentar 'Bestellnummer',
  -> Preis Dezimalzahl (10,2) nicht null Standard 0 Kommentar 'Bestellmenge',
  -> Primärschlüssel (ID)
  ->)Kommentar 'Bestelltabelle';
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)
mysql> in t_order (Preis) Werte (88,95), (100,68), (500), (300), (20,88), (200,5) einfügen;
Abfrage OK, 6 Zeilen betroffen (0,01 Sek.)
Datensätze: 6 Duplikate: 0 Warnungen: 0
mysql> wähle * aus t_order;
+----+--------+
| ID | Preis |
+----+--------+
| 1 | 88,95 |
| 2 | 100,68 |
| 3 | 500,00 |
| 4 | 300,00 |
| 5 | 20,88 |
| 6 | 200,50 |
+----+--------+
6 Zeilen im Satz (0,00 Sek.)
mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order a Limit 2;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 1 | 88,95 |
| 2 | 100,68 |
+--------------+--------------+
2 Zeilen im Satz (0,00 Sek.)
mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order a Limit 0,2;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 1 | 88,95 |
| 2 | 100,68 |
+--------------+--------------+
2 Zeilen im Satz (0,00 Sek.)

Holen Sie sich den größten Rekord

Wir müssen den Datensatz mit dem höchsten Bestellwert ermitteln. Dies erreichen wir, indem wir in absteigender Reihenfolge nach dem Betrag sortieren und dann den ersten Datensatz wie folgt nehmen:

mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 3 | 500,00 |
| 4 | 300,00 |
| 6 | 200,50 |
| 2 | 100,68 |
| 1 | 88,95 |
| 5 | 20,88 |
+--------------+--------------+
6 Zeilen im Satz (0,00 Sek.)
mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc limit 1;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 3 | 500,00 |
+--------------+--------------+
1 Zeile im Satz (0,00 Sek.)
mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc limit 0,1;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 3 | 500,00 |
+--------------+--------------+
1 Zeile im Satz (0,00 Sek.)

Erhalten Sie Datensätze mit einer Rangfolge von n bis m

Wir müssen zuerst n-1 Datensätze überspringen und dann m-n+1 Datensätze wie folgt nehmen:

Wähle Spalten aus Tabellenlimit n-1,m-n+1;

Wenn wir beispielsweise die Datensätze der Top 3 bis 5 mit dem höchsten Bestellwert erhalten möchten, müssen wir 2 Datensätze überspringen und dann 3 Datensätze wie folgt erhalten:

mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 3 | 500,00 |
| 4 | 300,00 |
| 6 | 200,50 |
| 2 | 100,68 |
| 1 | 88,95 |
| 5 | 20,88 |
+--------------+--------------+
6 Zeilen im Satz (0,00 Sek.)
mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc Limit 2,3;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 6 | 200,50 |
| 2 | 100,68 |
| 1 | 88,95 |
+--------------+--------------+
3 Zeilen im Satz (0,00 Sek.)

Paginierungsabfrage

Während des Entwicklungsprozesses verwenden wir häufig Paging, das im Allgemeinen zwei Parameter hat:
Seite: Gibt die Seitenzahl an, beginnend bei 1 und im Bereich von [1, +∞)
Seitengröße: wie viele Datensätze werden pro Seite angezeigt, Bereich [1, +∞)
Beispiel: Seite = 2, Seitengröße = 10, was bedeutet, dass 10 Datenelemente auf Seite 2 abgerufen werden.
Wir verwenden limit, um Paging zu implementieren. Die Syntax lautet wie folgt:

Wähle eine Spalte aus dem Tabellennamenlimit (Seite – 1) * Seitengröße, Seitengröße;

Anforderung: Wir zeigen 2 Artikel pro Seite in absteigender Reihenfolge des Bestellbetrags an und erhalten alle Bestelldaten, Daten von Seite 1, Seite 2 und Seite 3 nacheinander wie folgt:

mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 3 | 500,00 |
| 4 | 300,00 |
| 6 | 200,50 |
| 2 | 100,68 |
| 1 | 88,95 |
| 5 | 20,88 |
+--------------+--------------+
6 Zeilen im Satz (0,00 Sek.)
mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc limit 0,2;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 3 | 500,00 |
| 4 | 300,00 |
+--------------+--------------+
2 Zeilen im Satz (0,00 Sek.)
mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc Limit 2,2;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 6 | 200,50 |
| 2 | 100,68 |
+--------------+--------------+
2 Zeilen im Satz (0,00 Sek.)
mysql> wähle a.id Bestellnummer, a.price Bestellmenge aus t_order eine Bestellung nach a.price desc limit 4,2;
+--------------+--------------+
| Bestellnummer| Bestellmenge|
+--------------+--------------+
| 1 | 88,95 |
| 5 | 20,88 |
+--------------+--------------+
2 Zeilen im Satz (0,00 Sek.)

Vermeiden Sie Fallstricke

Ausdrücke können nicht in Grenzen verwendet werden

mysql> wähle * aus t_order, wobei Limit 1,4+1 ist;
FEHLER 1064 (42000): Ihre SQL-Syntax weist einen Fehler auf. Überprüfen Sie im Handbuch zu Ihrer MySQL-Serverversion, welche Syntax in der Nähe von „limit 1,4+1“ in Zeile 1 zu verwenden ist.
mysql> wähle * aus t_order, wobei Limit 1+0 ist;
FEHLER 1064 (42000): Ihre SQL-Syntax weist einen Fehler auf. Überprüfen Sie im Handbuch zu Ihrer MySQL-Serverversion, welche Syntax in der Nähe von „limit 1+0“ in Zeile 1 zu verwenden ist.
MySQL>

Fazit: Auf eine Grenze kann nur eine bestimmte Zahl folgen.

Die beiden Zahlen nach dem Limit dürfen nicht negativ sein.

mysql> wähle * aus t_order, wobei Limit -1 ist;
FEHLER 1064 (42000): Ihre SQL-Syntax weist einen Fehler auf. Überprüfen Sie im Handbuch zu Ihrer MySQL-Serverversion, welche Syntax in der Nähe von „limit -1“ in Zeile 1 zu verwenden ist.
mysql> wähle * aus t_order, wobei Limit 0,-1 ist;
FEHLER 1064 (42000): Ihre SQL-Syntax weist einen Fehler auf. Überprüfen Sie im Handbuch zu Ihrer MySQL-Serverversion die richtige Syntax für die Stelle „limit 0,-1“ in Zeile 1.
mysql> wähle * aus t_order, wobei Limit -1,-1 ist;
FEHLER 1064 (42000): Ihre SQL-Syntax weist einen Fehler auf. Überprüfen Sie im Handbuch zu Ihrer MySQL-Serverversion, welche Syntax in der Nähe von „limit -1,-1“ in Zeile 1 zu verwenden ist.

Die Fallstricke beim Sortieren von Seiten

Bereiten Sie die Daten vor:

mysql> in test1 einfügen (b) Werte (1),(2),(3),(4),(2),(2),(2),(2);
Abfrage OK, 8 Zeilen betroffen (0,01 Sek.)
Datensätze: 8 Duplikate: 0 Warnungen: 0
mysql> wähle * aus test1;
+---+---+
| ein | b |
+---+---+
| 1 | 1 |
| 2 | 2 |
| 3 | 3 |
| 4 | 4 |
| 5 | 2 |
| 6 | 2 |
| 7 | 2 |
| 8 | 2 |
+---+---+
8 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus Test1, sortiert nach b asc;
+---+---+
| ein | b |
+---+---+
| 1 | 1 |
| 2 | 2 |
| 5 | 2 |
| 6 | 2 |
| 7 | 2 |
| 8 | 2 |
| 3 | 3 |
| 4 | 4 |
+---+---+
8 Zeilen im Satz (0,00 Sek.)

Als nächstes erhalten wir die Daten in aufsteigender Reihenfolge von b, mit 2 Datensätzen pro Seite.

Das folgende SQL stellt die Daten von Seite 1, Seite 2, Seite 3, Seite 4 und Seite 5 wie folgt dar:

mysql> Auswahl * aus Test1, Reihenfolge nach b, asc, Limit 0,2;
+---+---+
| ein | b |
+---+---+
| 1 | 1 |
| 2 | 2 |
+---+---+
2 Zeilen im Satz (0,00 Sek.)
mysql> Auswahl * aus Test1, Reihenfolge nach b, asc, Limit 2,2;
+---+---+
| ein | b |
+---+---+
| 8 | 2 |
| 6 | 2 |
+---+---+
2 Zeilen im Satz (0,00 Sek.)
mysql> Auswahl * aus Test1, Reihenfolge nach b, asc, Limit 4,2;
+---+---+
| ein | b |
+---+---+
| 6 | 2 |
| 7 | 2 |
+---+---+
2 Zeilen im Satz (0,00 Sek.)
mysql> Auswahl * aus Test1, Reihenfolge nach b, asc, Limit 6,2;
+---+---+
| ein | b |
+---+---+
| 3 | 3 |
| 4 | 4 |
+---+---+
2 Zeilen im Satz (0,00 Sek.)
mysql> Auswahl * aus Test1, Reihenfolge nach b, asc, Limit 7,2;
+---+---+
| ein | b |
+---+---+
| 4 | 4 |
+---+---+
1 Zeile im Satz (0,00 Sek.)

Oben stehen 2 Fragen:

Frage 1: Sehen Sie sich das zweite und dritte SQL an. Es sind die Daten von Seite 2 bzw. Seite 3. In den Ergebnissen erscheinen dieselben Daten. Sind Sie verwirrt?

Frage 2: Die gesamte Tabelle enthält nur 8 Datensätze. Wie kommt es also, dass Daten auf Seite 5 erscheinen? Ich bin wieder verwirrt.

Lassen Sie uns die oben genannten Gründe analysieren: Der Hauptgrund ist, dass das Feld B denselben Wert hat. Wenn während des Sortiervorgangs derselbe Wert vorhanden ist und keine anderen Sortierregeln vorhanden sind, ist MySQL verwirrt und weiß nicht, wie es sortieren soll.

Wir sortieren nach Größe, genau wie wir uns in der Schule in einer Reihe aufstellen. Wie sortieren wir also, wenn alle gleich groß sind? Die gleich hohen werden dabei zufällig angeordnet.

Vorschlag: Wenn es bei der Sortierung identische Werte gibt, müssen Sie eine andere Sortierregel angeben. Diese Sortierregel ist eindeutig. Sie können beispielsweise wie folgt eine absteigende Sortierung zu der obigen hinzufügen:

mysql> wähle * aus Test1, sortiert nach b asc,a desc;
+---+---+
| ein | b |
+---+---+
| 1 | 1 |
| 8 | 2 |
| 7 | 2 |
| 6 | 2 |
| 5 | 2 |
| 2 | 2 |
| 3 | 3 |
| 4 | 4 |
+---+---+
8 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus Test1, sortiert nach b asc,a desc, Limit 0,2;
+---+---+
| ein | b |
+---+---+
| 1 | 1 |
| 8 | 2 |
+---+---+
2 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus Test1, sortiert nach b asc,a desc, Limit 2,2;
+---+---+
| ein | b |
+---+---+
| 7 | 2 |
| 6 | 2 |
+---+---+
2 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus Test1, sortiert nach b asc,a desc, Limit 4,2;
+---+---+
| ein | b |
+---+---+
| 5 | 2 |
| 2 | 2 |
+---+---+
2 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus Test1, sortiert nach b asc,a desc, Limit 6,2;
+---+---+
| ein | b |
+---+---+
| 3 | 3 |
| 4 | 4 |
+---+---+
2 Zeilen im Satz (0,00 Sek.)
mysql> wähle * aus Test1, sortiert nach b asc,a desc Limit 8,2;
Leerer Satz (0,00 Sek.)

Wenn man sich die Ergebnisse oben ansieht, sind die Paging-Daten normal und auf Seite 5 sind keine Daten vorhanden.

Zusammenfassen

  • order by ... [asc|desc] dient zum Sortieren der Abfrageergebnisse, asc: aufsteigend, desc: absteigend, asc|desc kann weggelassen werden, die Vorgabe ist asc
  • Mit „limit“ wird die Anzahl der Zeilen begrenzt, die vom Abfrageergebnis zurückgegeben werden. Es verfügt über zwei Parameter (Offset, Anzahl). „Offset“ gibt an, wie viele Zeilen übersprungen werden sollen, und „Anzahl“ gibt an, dass die Offset-Zeile übersprungen und dann die Anzahl der Zeilen übernommen werden soll.
  • Der Offset im Limit kann weggelassen werden, der Standardwert ist 0
  • Sowohl Offset als auch Count-In-Limit müssen größer oder gleich 0 sein.
  • Die Werte von Offset und Anzahl im Limit können nicht als Ausdrücke ausgedrückt werden.
  • Beim Sortieren nach Seite sollte die Sortierung eindeutig sein. Mehrdeutigkeiten können dazu führen, dass die Seitenergebnisse nicht in der richtigen Reihenfolge sind. Sie können am Ende eine Primärschlüsselsortierung hinzufügen.

Dies ist das Ende dieses Artikels über MySQL-Sortierung und -Paginierung (Order by & Limit) und die bestehenden Fallstricke. Weitere relevante Inhalte zu MySQL-Sortierung und -Paginierung finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!

Das könnte Sie auch interessieren:
  • Sortierung und Paginierung von MySQL-Abfragen
  • Erläuterung der Sortierung und Paginierung in MySQL

<<:  Häufig verwendete JavaScript-Array-Methoden

>>:  Docker erstellt Python Flask+ Nginx+Uwsgi-Container

Artikel empfehlen

Analyse der prinzipiellen Implementierung aus dem Quellcode des Mini-Programm-Entwicklertools

Inhaltsverzeichnis So zeigen Sie den Quellcode de...

Detaillierter Prozess der Installation von Jenkins-2.249.3-1.1 mit Docker

Inhaltsverzeichnis 1. Docker installieren 2. Zieh...

Vue implementiert den automatischen Sprung zur Anmeldeseite, wenn das Token abläuft

Das Projekt wurde in diesen Tagen getestet und de...

Detaillierte Erläuterung der Galera-Cluster-Bereitstellung im Clustermodus von MySQL

Inhaltsverzeichnis 1: Einführung in Galera-Cluste...

Rastersysteme im Webdesign

Bildung des Gittersystems Im Jahr 1692 war der fr...

jQuery implementiert das Klicken auf die linke und rechte Schaltfläche zum Wechseln von Bildern

In diesem Artikelbeispiel wird der spezifische Co...

Zusammenfassung der in MySQL häufig verwendeten Verkettungsanweisungen

Vorwort: In MySQL wird die Funktion CONCAT() verw...

Ubuntu-Terminal, mehrere Fenster, geteilter Bildschirm, Terminator

1. Installation Das größte Feature von Terminator...

So starten Sie ein JAR-Paket und führen es unter Linux im Hintergrund aus

Der Linux-Befehl zum Ausführen des JAR-Pakets lau...

Bild-Scrolling-Effekt mit CSS3 erstellt

Ergebnisse erzielenImplementierungscode html <...

Beispielcode für ungewöhnliche HTML-Tags „optgroup“, „sub“, „sup“ und „bdo“

Optgroup wird im Auswahltag verwendet, um den Inha...

Vue implementiert dynamische Routingdetails

Inhaltsverzeichnis 1. Frontend-Steuerung 1. In de...

Mit wie vielen Pixeln sollte eine Webseite gestaltet werden?

Viele Webdesigner sind beim Entwurf des Webseitenl...

Detaillierte Erläuterung der passwortfreien SSH-Anmeldekonfigurationsmethode (Bilder und Befehle)

Lassen Sie mich zunächst erklären, dass wir uns o...

Idea konfiguriert Tomcat zum Starten eines Webprojekts - Grafik-Tutorial

Tomcat konfigurieren 1. Klicken Sie auf „Konfigur...