🧚 Hör mal! Beekeeper Studio ist eine schnelle, moderne Open-Source-Datenbank-GUI Download
8. Januar 2026 Von Matthew Rathbone

ORDER BY sortiert die Zeilen, die eine Abfrage zurückgibt, nach einer oder mehreren Spalten oder Ausdrücken, aufsteigend oder absteigend. Ohne ORDER BY liefert die Datenbank die Zeilen in der Reihenfolge, die gerade am schnellsten geht. Die Beispiele funktionieren in PostgreSQL, MySQL, SQLite und SQL Server.

So verwendest du ORDER BY

Setz ORDER BY ans Ende der Abfrage, nach WHERE, GROUP BY und HAVING; nur LIMIT kommt danach. Gib die Spalten an, nach denen sortiert werden soll. Jede wird aufsteigend sortiert, außer du fügst DESC hinzu:

SELECT columns
FROM table_name
ORDER BY column1 [ASC | DESC], column2 [ASC | DESC];

-- Input: customers
-- customer_id | name        | signup_date
-- ------------+-------------+------------
-- 1           | Olivia Hart | 2024-03-12
-- 2           | Marcus Lee  | 2023-11-05
-- 3           | Zara Ahmed  | 2024-01-27
-- 4           | Ben Carter  | 2023-08-19

SELECT customer_id, name, signup_date
FROM customers
ORDER BY signup_date;

-- Output:
-- customer_id | name        | signup_date
-- ------------+-------------+------------
-- 4           | Ben Carter  | 2023-08-19
-- 2           | Marcus Lee  | 2023-11-05
-- 3           | Zara Ahmed  | 2024-01-27
-- 1           | Olivia Hart | 2024-03-12

SELECT customer_id, name, signup_date
FROM customers
ORDER BY signup_date DESC;

-- Output:
-- customer_id | name        | signup_date
-- ------------+-------------+------------
-- 1           | Olivia Hart | 2024-03-12
-- 3           | Zara Ahmed  | 2024-01-27
-- 2           | Marcus Lee  | 2023-11-05
-- 4           | Ben Carter  | 2023-08-19

Wichtige Regeln

  • DESC gilt nur für die Spalte direkt davor. ORDER BY author, published DESC sortiert die Autoren von A bis Z und dann die Bücher jedes Autors mit den neuesten zuerst:
-- Input: books
-- title               | author          | published
-- --------------------+-----------------+----------
-- Emma                | Jane Austen     | 1815
-- Bleak House         | Charles Dickens | 1853
-- Pride and Prejudice | Jane Austen     | 1813
-- Hard Times          | Charles Dickens | 1854

SELECT title, author, published
FROM books
ORDER BY author, published DESC;

-- Output:
-- title               | author          | published
-- --------------------+-----------------+----------
-- Hard Times          | Charles Dickens | 1854
-- Bleak House         | Charles Dickens | 1853
-- Emma                | Jane Austen     | 1815
-- Pride and Prejudice | Jane Austen     | 1813
  • Ohne ORDER BY ist die Reihenfolge nicht garantiert. Zeilen kommen oft in der Reihenfolge zurück, in der sie eingefügt wurden – bis die Tabelle wächst, sich ein Index ändert oder die Abfrage parallel läuft. Das gilt auch für LIMIT: Ohne ORDER BY liefert es die Zeilen, die die Datenbank zuerst liest.
  • Gleichrangige Zeilen kommen in beliebiger Reihenfolge zurück. Füg eine eindeutige Spalte wie die ID als letzte Sortierspalte hinzu, damit die Reihenfolge bei jedem Durchlauf gleich ist:
-- Input: customers
-- customer_id | name       | signup_date
-- ------------+------------+------------
-- 3           | Mara Lind  | 2024-01-15
-- 1           | Owen Price | 2024-01-10
-- 4           | Tariq Aziz | 2024-01-15
-- 2           | Lily Shore | 2024-01-15

-- The three 2024-01-15 rows can come back in any order
SELECT * FROM customers ORDER BY signup_date;

-- Output:
-- customer_id | name       | signup_date
-- ------------+------------+------------
-- 1           | Owen Price | 2024-01-10
-- 3           | Mara Lind  | 2024-01-15
-- 4           | Tariq Aziz | 2024-01-15
-- 2           | Lily Shore | 2024-01-15

-- customer_id breaks the tie
SELECT * FROM customers ORDER BY signup_date, customer_id;

-- Output:
-- customer_id | name       | signup_date
-- ------------+------------+------------
-- 1           | Owen Price | 2024-01-10
-- 2           | Lily Shore | 2024-01-15
-- 3           | Mara Lind  | 2024-01-15
-- 4           | Tariq Aziz | 2024-01-15
  • NULL-Werte werden zuerst sortiert, außer in PostgreSQL, das sie ans Ende setzt. Das gilt für aufsteigende Sortierung; DESC dreht es um:
-- Input: users
-- name       | middle_name
-- -----------+------------
-- John Smith | Robert
-- Ana Lopez  | NULL
-- Kim Young  | Elise

SELECT name, middle_name
FROM users
ORDER BY middle_name;

-- Output:
-- name       | middle_name
-- -----------+------------
-- Ana Lopez  | NULL
-- Kim Young  | Elise
-- John Smith | Robert
-- (PostgreSQL puts Ana Lopez last instead)

Wie du selbst festlegst, wo NULL-Werte landen, zeigen NULLS FIRST und NULLS LAST weiter unten.

Alternative Syntax

Du kannst nach einem Spaltenalias oder nach der Position der Spalte in der SELECT-Liste sortieren. Ein Alias erspart dir, einen Ausdruck zu wiederholen. Eine Position ist kürzer, geht aber unbemerkt kaputt, wenn jemand die SELECT-Liste ändert:

-- Input: employees
-- name     | monthly_salary
-- ---------+---------------
-- Ivy Chen | 5200
-- Max Dunn | 7600
-- Pia Roth | 4500

SELECT name, monthly_salary * 12 AS annual_salary
FROM employees
ORDER BY annual_salary DESC;  -- or ORDER BY 2 DESC

-- Output:
-- name     | annual_salary
-- ---------+--------------
-- Max Dunn | 91200
-- Ivy Chen | 62400
-- Pia Roth | 54000

NULLS FIRST und NULLS LAST nach einer Sortierspalte legen fest, wo ihre NULL-Werte landen:

-- Input: the users table above

SELECT name, middle_name
FROM users
ORDER BY middle_name NULLS LAST;
-- MySQL and SQL Server don't support NULLS LAST. Sort on a CASE first instead:
-- ORDER BY CASE WHEN middle_name IS NULL THEN 1 ELSE 0 END, middle_name

-- Output:
-- name       | middle_name
-- -----------+------------
-- Kim Young  | Elise
-- John Smith | Robert
-- Ana Lopez  | NULL

MySQL hat FIELD(), das Werte in der Reihenfolge sortiert, in der du sie angibst. Anderswo nimmst du einen CASE-Ausdruck wie in Aufgaben nach Priorität sortieren weiter unten:

-- Input: products
-- product_name | category
-- -------------+------------
-- Cookbook     | Books
-- Raincoat     | Clothing
-- Tablet       | Electronics
-- Scarf        | Clothing

-- MySQL
SELECT * FROM products
ORDER BY FIELD(category, 'Electronics', 'Clothing', 'Books');

-- Output:
-- product_name | category
-- -------------+------------
-- Tablet       | Electronics
-- Raincoat     | Clothing
-- Scarf        | Clothing
-- Cookbook     | Books

Wann solltest du ORDER BY verwenden?

Verwende ORDER BY immer dann, wenn die Reihenfolge der Zeilen für die Leser eine Bedeutung hat. Die meisten Anwendungsfälle fallen in eine dieser vier Kategorien.

Eine Liste in vorhersehbarer Reihenfolge anzeigen

Namen von A bis Z, Datumswerte mit den ältesten zuerst, IDs der Reihe nach. Ohne ORDER BY kann dieselbe Abfrage ihre Zeilen bei jedem Durchlauf in anderer Reihenfolge liefern, und Ergebnisseiten können sich überschneiden oder Zeilen auslassen.

Die höchsten oder neuesten Werte finden

Sortiere absteigend, um die größten, neuesten oder teuersten Zeilen nach vorne zu holen, und füg dann LIMIT hinzu, um nur die ersten paar zu behalten: Bestseller, die letzten Bestellungen, die höchsten Punktzahlen.

Nach mehr als einer Spalte sortieren

Wenn die erste Sortierspalte gleiche Werte hat, entscheidet die nächste über die Reihenfolge innerhalb dieser Gruppe: Abteilung dann Gehalt, Klasse dann Punktzahl, Status dann Datum. Jede Spalte kann ihre eigene Richtung haben.

Nach einem berechneten Wert oder einer eigenen Reihenfolge sortieren

ORDER BY akzeptiert jeden Ausdruck, nicht nur Spalten: eine aus zwei Spalten berechnete Summe, die Länge eines Namens oder einen CASE-Ausdruck, der Werte wie High, Medium und Low in eine Reihenfolge bringt, die das Alphabet nicht hergibt.

Praxisbeispiele für ORDER BY

Durch eine Kundenliste blättern

ORDER BY mit LIMIT und OFFSET liefert jeweils eine Seite. Drei Kunden haben sich am selben Tag registriert, also entscheidet customer_id bei Gleichstand. Ohne diese Spalte könnte die Datenbank denselben Kunden auf beide Seiten setzen und einen anderen auslassen:

-- Input: customers
-- customer_id | name        | signup_date
-- ------------+-------------+------------
-- 1           | Nina Brandt | 2024-02-14
-- 2           | Theo Walsh  | 2023-09-30
-- 3           | Iris Novak  | 2024-02-14
-- 4           | Felix Moore | 2024-02-14
-- 5           | June Park   | 2024-03-22

-- Page 1
SELECT customer_id, name, signup_date
FROM customers
ORDER BY signup_date, customer_id
LIMIT 2 OFFSET 0;

-- Output:
-- customer_id | name        | signup_date
-- ------------+-------------+------------
-- 2           | Theo Walsh  | 2023-09-30
-- 1           | Nina Brandt | 2024-02-14

-- Page 2
SELECT customer_id, name, signup_date
FROM customers
ORDER BY signup_date, customer_id
LIMIT 2 OFFSET 2;
-- SQL Server has no LIMIT: use OFFSET 2 ROWS FETCH NEXT 2 ROWS ONLY

-- Output:
-- customer_id | name        | signup_date
-- ------------+-------------+------------
-- 3           | Iris Novak  | 2024-02-14
-- 4           | Felix Moore | 2024-02-14

Die Top drei einer Bestenliste anzeigen

Sortiere die Punktzahlen von der höchsten zur niedrigsten und behalte die ersten drei:

-- Input: players
-- username  | score
-- ----------+------
-- quokka42  | 1870
-- nightowl  | 2310
-- pixelpete | 1525
-- zara_k    | 2045
-- bytebard  | 1990

SELECT username, score
FROM players
ORDER BY score DESC
LIMIT 3;
-- SQL Server has no LIMIT: write SELECT TOP 3 username, score instead

-- Output:
-- username | score
-- ---------+------
-- nightowl | 2310
-- zara_k   | 2045
-- bytebard | 1990

Einen Bestellbericht nach Status, Wert und Datum erstellen

Die Status werden alphabetisch sortiert. Innerhalb jedes Status kommen die größten Bestellungen zuerst, und bei Bestellungen mit gleichem Wert die neuesten zuerst:

-- Input: orders
-- order_id | status     | order_value | order_date
-- ---------+------------+-------------+-----------
-- 1001     | Shipped    | 120.00      | 2024-03-02
-- 1002     | Delivered  | 75.50       | 2024-02-20
-- 1003     | Shipped    | 120.00      | 2024-03-05
-- 1004     | Processing | 42.00       | 2024-03-06
-- 1005     | Delivered  | 210.00      | 2024-02-28

SELECT order_id, status, order_value, order_date
FROM orders
ORDER BY status ASC, order_value DESC, order_date DESC;

-- Output:
-- order_id | status     | order_value | order_date
-- ---------+------------+-------------+-----------
-- 1005     | Delivered  | 210.00      | 2024-02-28
-- 1002     | Delivered  | 75.50       | 2024-02-20
-- 1004     | Processing | 42.00       | 2024-03-06
-- 1003     | Shipped    | 120.00      | 2024-03-05
-- 1001     | Shipped    | 120.00      | 2024-03-02

Aufgaben nach Priorität sortieren

Alphabetisch käme High, Low, Medium heraus. Ein CASE-Ausdruck wandelt jede Priorität in eine Zahl um, nach der sortiert wird. Alles andere, hier ein NULL, bekommt 4 und landet am Ende, und das Fälligkeitsdatum ordnet die Aufgaben innerhalb jeder Priorität:

-- Input: tasks
-- task_name      | priority | due_date
-- ---------------+----------+-----------
-- Update docs    | Low      | 2024-06-03
-- Fix login bug  | High     | 2024-06-10
-- Plan offsite   | NULL     | 2024-05-20
-- Renew SSL cert | High     | 2024-06-01
-- Review PR      | Medium   | 2024-06-04

SELECT task_name, priority, due_date
FROM tasks
ORDER BY
  CASE priority
    WHEN 'High' THEN 1
    WHEN 'Medium' THEN 2
    WHEN 'Low' THEN 3
    ELSE 4
  END,
  due_date;

-- Output:
-- task_name      | priority | due_date
-- ---------------+----------+-----------
-- Renew SSL cert | High     | 2024-06-01
-- Fix login bug  | High     | 2024-06-10
-- Review PR      | Medium   | 2024-06-04
-- Update docs    | Low      | 2024-06-03
-- Plan offsite   | NULL     | 2024-05-20

Weiterführende Artikel zu ORDER BY

Hier im Blog:

Offizielle Dokumentation:

Beekeeper Studio ist eine kostenlose & quelloffene Datenbank-GUI

Das beste SQL-Abfrage- & Editor-Tool, das ich je benutzt habe. Es bietet alles, was ich zum Verwalten meiner Datenbank brauche. - ⭐⭐⭐⭐⭐ Mit

Beekeeper Studio ist schnell, intuitiv und einfach zu bedienen. Beekeeper unterstützt jede Menge Datenbanken und läuft hervorragend auf Windows, Mac und Linux.

download Kostenlos herunterladen
Die Linux-Version von Beekeeper hat 100% des Funktionsumfangs, ohne Abstriche und ohne Kompromisse.

Was Nutzer über Beekeeper Studio sagen

★★★★★
„Beekeeper Studio hat meinen alten SQL-Workflow komplett ersetzt. Es ist schnell, intuitiv und macht die Arbeit mit Datenbanken wieder zum Vergnügen.“
— Alex K., Datenbankentwickler
★★★★★
„Ich habe viele Datenbank-GUIs ausprobiert, aber Beekeeper findet die perfekte Balance zwischen Funktionsumfang und Einfachheit. Es funktioniert einfach.“
— Sarah M., Full-Stack-Entwicklerin

Bereit, deinen SQL-Workflow zu verbessern?

download Kostenlos herunterladen

Alle Editionen ansehen →