menu
languageDeutsch
save_alt Download

SQL Cheat Sheet

Die wichtigsten SQL-Befehle und Syntax-Referenz für Datenbankabfragen

🔍 SELECT-Grundlagen

Lies Daten aus Tabellen, indem du angibst, welche Spalten zurückgegeben werden sollen. Mit DISTINCT entfernst du Duplikate, mit AS vergibst du Spaltenaliase.
SELECT customer_id, name, email
FROM customers;

-- With alias and DISTINCT
SELECT DISTINCT country AS customer_country
FROM customers;

Das Wichtigste:

  • Gib konkrete Spalten statt * an – das ist performanter
  • DISTINCT entfernt doppelte Zeilen
  • Das Schlüsselwort AS erstellt Spaltenaliase
  • Die Spaltenreihenfolge im SELECT bestimmt die Reihenfolge im Ergebnis

⚡ WHERE-Klausel

Filtere Zeilen anhand von Bedingungen mit Vergleichsoperatoren. Kombiniere mehrere Bedingungen mit AND/OR für komplexe Filter.
SELECT name, price
FROM products
WHERE price > 100;

-- Multiple conditions
SELECT name, category
FROM products
WHERE category = 'Electronics'
  AND price <= 500;

Das Wichtigste:

  • Filtert Zeilen, bevor Ergebnisse zurückgegeben werden
  • Mehrere Bedingungen lassen sich mit AND/OR kombinieren
  • String-Werte brauchen einfache Anführungszeichen
  • Operatoren: =, !=, <>, <, >, <=, >=

⚙️ Logische Operatoren

Kombiniere mehrere Bedingungen mit AND (alle müssen zutreffen), OR (mindestens eine muss zutreffen) und NOT (negiert die Bedingung).
-- AND operator
SELECT * FROM orders
WHERE status = 'shipped' AND total > 100;

-- OR operator
SELECT * FROM customers
WHERE country = 'USA' OR country = 'Canada';

-- NOT operator
SELECT * FROM products
WHERE NOT category = 'Discontinued';

Das Wichtigste:

  • AND hat Vorrang vor OR
  • Steuere die Auswertungsreihenfolge mit Klammern
  • NOT entspricht != oder <>
  • Kombiniere Operatoren für komplexe Logik

↕️ ORDER BY

Sortiere Abfrageergebnisse aufsteigend (ASC) oder absteigend (DESC). Für komplexe Sortierungen sortierst du nach mehreren Spalten.
-- Single column sort
SELECT name, price
FROM products
ORDER BY price DESC;

-- Multiple columns
SELECT name, category, price
FROM products
ORDER BY category ASC, price DESC;

Das Wichtigste:

  • Ohne Angabe gilt ASC als Standard
  • Sortierung nach mehreren Spalten (Priorität von links nach rechts)
  • Du kannst nach Spalten sortieren, die nicht im SELECT stehen
  • NULL-Werte stehen zuerst oder zuletzt (je nach Datenbank)

✂️ LIMIT / OFFSET

Begrenze die Anzahl der zurückgegebenen Zeilen und überspringe Zeilen mit OFFSET. Unverzichtbar für Paginierung und große Ergebnismengen.
-- First 10 rows
SELECT name, price
FROM products
ORDER BY price DESC
LIMIT 10;

-- Pagination (skip first 20, get next 10)
SELECT name, price
FROM products
ORDER BY price DESC
LIMIT 10 OFFSET 20;

Das Wichtigste:

  • Unverzichtbar für Paginierung
  • Mit ORDER BY kombinieren für konsistente Ergebnisse
  • OFFSET beginnt bei 0 (erste Zeile)
  • Hinweis: SQL Server verwendet TOP statt LIMIT

*️⃣ Mustervergleich (LIKE)

Vergleiche Textmuster mit Platzhaltern: % steht für eine beliebige Zeichenfolge, _ für genau ein Zeichen.
-- Starts with 'John'
SELECT name, email
FROM customers
WHERE name LIKE 'John%';

-- Contains 'smith'
SELECT name FROM customers
WHERE name LIKE '%smith%';

-- Exact pattern (5 characters starting with 'A')
SELECT code FROM products
WHERE code LIKE 'A____';

Das Wichtigste:

  • % steht für null oder mehr Zeichen
  • _ steht für genau ein Zeichen
  • Groß-/Kleinschreibung hängt von der Collation der Datenbank ab
  • Mit NOT LIKE schließt du Treffer aus

↔️ Bereiche & Mengen (BETWEEN, IN)

Filtere Bereiche mit BETWEEN (inklusive) oder Werte aus einer Liste mit IN. Effizienter als mehrere OR-Bedingungen.
-- BETWEEN (inclusive)
SELECT name, price
FROM products
WHERE price BETWEEN 50 AND 100;

-- IN operator
SELECT name, country
FROM customers
WHERE country IN ('USA', 'Canada', 'Mexico');

-- NOT IN
SELECT name FROM products
WHERE category NOT IN ('Discontinued', 'Draft');

Das Wichtigste:

  • BETWEEN schließt beide Grenzwerte ein
  • IN ist übersichtlicher als mehrere OR-Bedingungen
  • IN funktioniert auch mit Unterabfragen
  • BETWEEN funktioniert mit Datumswerten und Strings

❓ Umgang mit NULL

Arbeite mit NULL-Werten über IS NULL und IS NOT NULL. Mit COALESCE legst du Standardwerte für NULL-Spalten fest.
-- Find NULL values
SELECT name, phone
FROM customers
WHERE phone IS NULL;

-- Exclude NULL values
SELECT name, email
FROM customers
WHERE email IS NOT NULL;

-- Provide default value
SELECT name, COALESCE(phone, 'No phone') AS contact
FROM customers;

Das Wichtigste:

  • = oder != funktionieren nicht mit NULL
  • Verwende immer IS NULL oder IS NOT NULL
  • COALESCE gibt das erste Argument ungleich NULL zurück
  • NULL in Rechenoperationen ergibt NULL

Σ Aggregatfunktionen

Führe Berechnungen über Zeilenmengen aus: COUNT, SUM, AVG, MIN, MAX. Aggregate ignorieren NULL-Werte (außer COUNT(*)).
-- Basic aggregates
SELECT
  COUNT(*) AS total_orders,
  SUM(amount) AS total_revenue,
  AVG(amount) AS avg_order_value,
  MIN(amount) AS smallest_order,
  MAX(amount) AS largest_order
FROM orders;

-- COUNT variations
SELECT COUNT(*) AS all_rows,
       COUNT(email) AS rows_with_email,
       COUNT(DISTINCT country) AS unique_countries
FROM customers;

Das Wichtigste:

  • COUNT(*) zählt alle Zeilen (auch mit NULL)
  • COUNT(column) lässt NULL-Werte aus
  • COUNT(DISTINCT column) zählt eindeutige Werte
  • SUM/AVG funktionieren nur mit numerischen Typen

▦ GROUP BY / HAVING

Gruppiere Zeilen nach Spaltenwerten und wende Aggregatfunktionen an. Mit HAVING filterst du Gruppen (wie WHERE, nur für Gruppen).
-- Group by single column
SELECT country, COUNT(*) AS customer_count
FROM customers
GROUP BY country
ORDER BY customer_count DESC;

-- Group by multiple columns with HAVING
SELECT category, status, AVG(price) AS avg_price
FROM products
GROUP BY category, status
HAVING AVG(price) > 50;

Das Wichtigste:

  • Alle nicht aggregierten SELECT-Spalten müssen im GROUP BY stehen
  • WHERE filtert Zeilen vor dem Gruppieren
  • HAVING filtert Gruppen nach der Aggregation
  • In der HAVING-Klausel sind Aggregatfunktionen erlaubt

🔗 Joins (Kurzreferenz) ZUM AUSFÜHRLICHEN GUIDE

Kombiniere Daten aus mehreren Tabellen anhand verknüpfter Spalten. INNER JOIN liefert nur Übereinstimmungen, LEFT/RIGHT behalten eine Seite vollständig.
-- INNER JOIN (most common)
SELECT orders.id, customers.name, orders.amount
FROM orders
INNER JOIN customers
  ON orders.customer_id = customers.id;

-- LEFT JOIN (all orders, even without customer)
SELECT orders.id, customers.name
FROM orders
LEFT JOIN customers
  ON orders.customer_id = customers.id;

Das Wichtigste:

  • INNER JOIN ist am gebräuchlichsten (kurz auch nur JOIN)
  • LEFT/RIGHT JOINs behalten alle Zeilen einer Tabelle
  • Die Join-Bedingung legst du mit der ON-Klausel fest

⬚ Unterabfragen

Abfragen innerhalb von Abfragen für komplexe Filter und Berechnungen. Einsetzbar mit IN, EXISTS oder als Skalarwert.
-- Subquery with IN
SELECT name, price
FROM products
WHERE category_id IN (
  SELECT id FROM categories
  WHERE name = 'Electronics'
);

-- Subquery with EXISTS
SELECT name FROM customers c
WHERE EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id
);

-- Scalar subquery
SELECT name, price,
  price - (SELECT AVG(price) FROM products) AS price_diff
FROM products;

Das Wichtigste:

  • Eine IN-Unterabfrage liefert mehrere Werte
  • EXISTS prüft auf Vorhandensein (effizient)
  • Eine skalare Unterabfrage liefert einen einzelnen Wert
  • Eine korrelierte Unterabfrage referenziert die äußere Abfrage

✂️ String-Funktionen

Extrahiere, transformiere und formatiere Textdaten. SUBSTRING extrahiert nach Position, LEFT/RIGHT greifen vom Anfang bzw. Ende zu.
-- Extract characters by position
SELECT SUBSTRING(name, 1, 3) AS prefix FROM products;

-- First / last N characters
SELECT LEFT(email, 5), RIGHT(phone, 4) FROM users;

-- Dynamic position (find @ then extract domain)
SELECT SUBSTRING(email, INSTR(email, '@') + 1) AS domain
FROM users;

-- Common string helpers
SELECT
  UPPER(name), LOWER(name),
  TRIM(name),
  LENGTH(name)
FROM users;

Das Wichtigste:

  • Positionen in SQL beginnen bei 1 (erstes Zeichen = Position 1)
  • LEFT/RIGHT für Anfang/Ende, SUBSTRING für die Mitte
  • SQLite unterstützt kein LEFT/RIGHT – nimm SUBSTRING
  • Oracle verwendet SUBSTR(), nicht SUBSTRING()

Suchst du einen besseren Weg, SQL zu schreiben?

Beekeeper Studio ist ein moderner, intuitiver SQL-Editor mit Autovervollständigung, Abfrageverlauf und Unterstützung für über 15 Datenbanken.

Beekeeper Studio gratis testen