SQLite Mathe-Funktionen: ROUND, ABS, CEIL, FLOOR & Co.

SQLite kann mehr Mathe, als du denkst

SQLite gilt als minimalistisch, bringt aber einen kompletten Satz numerischer Funktionen mit: Runden, Absolutbetrag, Auf- und Abrunden, Potenzen, Wurzeln, Logarithmen, Trigonometrie und Zufallszahlen. Die meisten dieser Mathe-Funktionen kamen mit SQLite 3.35 (2021) dazu — jede halbwegs aktuelle Installation hat sie also dabei, egal ob du sie über Python, Node, den offiziellen CLI-Client oder einen anderen modernen Wrapper nutzt.

Vorab ein kleiner Vorgeschmack, bevor wir ins Detail gehen:

SELECT
    ROUND(3.14159, 2)   AS rounded,
    ABS(-42)            AS absolute,
    CEIL(2.1)           AS ceiling,
    FLOOR(2.9)          AS floor_val,
    POWER(2, 10)        AS two_to_ten,
    SQRT(144)           AS root;

Sechs Funktionen, eine Ergebniszeile. Auf dem Rest der Seite gehen wir Schritt für Schritt durch die einzelnen Funktionsfamilien und die Stolperfallen, die du kennen solltest.

ROUND: Die Funktion, die du am häufigsten brauchst

ROUND(value, digits) rundet auf eine bestimmte Anzahl Nachkommastellen. Das zweite Argument ist optional – lässt du es weg, wird auf die nächste ganze Zahl gerundet (das Ergebnis bleibt aber ein Fließkommawert):

SELECT
    ROUND(3.14159)       AS no_digits,
    ROUND(3.14159, 2)    AS two_places,
    ROUND(3.14159, 4)    AS four_places,
    ROUND(2.5)           AS half_up,
    ROUND(-2.5)          AS half_down;

Ein paar Dinge, die du dir merken solltest:

• ROUND(3.14159) liefert 3.0, nicht 3. Wenn du wirklich einen Integer willst, nimm CAST(ROUND(x) AS INTEGER) – oder gleich CAST(x AS INTEGER), falls du einfach abschneiden möchtest.
• SQLite rundet nach dem Prinzip "kaufmännisch von Null weg": 2.5 wird zu 3, -2.5 zu -3. Manche Datenbanken verwenden das mathematische Runden (Banker's Rounding, also zur nächsten geraden Zahl) – SQLite eben nicht.
• Das Argument digits darf auch negativ sein: ROUND(1234.5, -2) rundet auf die nächsten 100, also 1200.0.

In der Praxis schreibst du ROUND(price, 2) vermutlich vor allem dann, wenn du Geldbeträge anzeigen willst.

ROUND vs. CAST: zwei verschiedene Welten

Viele greifen zu CAST(x AS INTEGER), wenn sie eigentlich runden wollen – und tappen prompt in die Falle:

SELECT
    CAST(2.9 AS INTEGER)   AS cast_truncates,
    ROUND(2.9)             AS round_rounds,
    CAST(-2.9 AS INTEGER)  AS cast_negative,
    ROUND(-2.9)            AS round_negative;

CAST schneidet einfach in Richtung Null ab – der Nachkommateil fliegt raus. ROUND rundet dagegen zur nächsten ganzen Zahl. Bei 2.9 liegen also ganze 1.0 zwischen den beiden Ergebnissen. Nimm die Funktion, deren Verhalten du wirklich brauchst.

ABS, SIGN und das Vorzeichen einer Zahl

ABS(x) liefert den Absolutwert. SIGN(x) gibt je nach Vorzeichen -1, 0 oder 1 zurück:

SELECT
    ABS(-17)    AS abs_neg,
    ABS(17)     AS abs_pos,
    ABS(0)      AS abs_zero,
    SIGN(-17)   AS sign_neg,
    SIGN(0)     AS sign_zero,
    SIGN(42.5)  AS sign_pos;

ABS ist der Klassiker – ideal für Abfragen wie „wie weit liegen diese beiden Werte auseinander". SIGN sieht man seltener, ist aber praktisch, wenn du Zeilen nach Vorzeichen gruppieren willst (Soll vs. Haben, Gewinn vs. Verlust), ohne extra ein CASE zu schreiben.

CEIL, FLOOR und TRUNC

Mit diesen Funktionen bekommst du ganzzahlige Werte, ohne kaufmännisch zu runden. CEIL rundet immer auf, FLOOR immer ab, und TRUNC schneidet einfach Richtung Null ab:

SELECT
    CEIL(2.1)    AS ceil_pos,
    CEIL(-2.1)   AS ceil_neg,
    FLOOR(2.9)   AS floor_pos,
    FLOOR(-2.9)  AS floor_neg,
    TRUNC(2.9)   AS trunc_pos,
    TRUNC(-2.9)  AS trunc_neg;

Achtung bei negativen Werten: FLOOR(-2.9) ergibt -3 (weiter weg von Null), während TRUNC(-2.9) -2 liefert (also Richtung Null gerundet). Sobald negative Zahlen ins Spiel kommen, gehen FLOOR und TRUNC getrennte Wege – und die falsche Wahl führt zum klassischen Off-by-One-Bug.

CEILING ist übrigens nur ein Alias für CEIL. Nimm einfach die Schreibweise, die dir besser gefällt.

Die eigentliche Stolperfalle: Integer-Division in SQLite

Streng genommen ist das gar keine Funktion, sondern der /-Operator – aber er sorgt bei Einsteigern für mehr Verwirrung als sämtliche Mathe-Funktionen zusammen:

SELECT
    5 / 2           AS int_div,
    5 / 2.0         AS real_div,
    5.0 / 2         AS also_real,
    CAST(5 AS REAL) / 2  AS explicit_cast;

Sobald beide Seiten Integer sind, macht SQLite eine Integer-Division und schneidet einfach ab. Sobald aber eine Seite ein REAL ist, wird der ganze Ausdruck zu einem Fließkommawert. Die Lösung: Mindestens einer der Operanden muss ein Float sein – entweder schreibst du 2.0 statt 2, oder du castest explizit.

Besonders fies wird das bei Spaltenreferenzen: total_cents / 100 liefert dir einen Integer zurück. total_cents / 100.0 ergibt dagegen den Dollarbetrag, den du eigentlich haben wolltest.

MOD und der %-Operator

MOD(x, y) gibt den Rest aus x / y zurück. Der Modulo-Operator % macht genau dasselbe:

SELECT
    MOD(17, 5)   AS mod_func,
    17 % 5       AS mod_op,
    MOD(-17, 5)  AS mod_neg,
    MOD(17, 0)   AS mod_zero;

MOD(17, 5) und 17 % 5 liefern beide 2. Modulo durch null gibt in SQLite NULL zurück – es wird also kein Fehler geworfen, was im Vergleich zu den meisten anderen Sprachen schon ungewöhnlich ist. Wenn dir das wichtig ist, prüfe den Divisor vorher oder pack den Aufruf in ein CASE WHEN y = 0 THEN ... END.

Funktion und Operator sind austauschbar. In der Praxis greifen die meisten zu %, einfach weil es kürzer ist.

POWER, SQRT, EXP, LOG

Für Potenzen und Wurzeln:

SELECT
    POWER(2, 10)    AS two_to_the_ten,
    POW(2, 0.5)     AS sqrt_via_power,
    SQRT(2)         AS sqrt_two,
    EXP(1)          AS e,
    LOG(100)        AS log10_100,
    LN(EXP(1))      AS ln_of_e;

Ein paar Stolperfallen, über die viele stolpern:

• POW ist nur ein Alias für POWER.
• LOG(x) rechnet in SQLite mit Basis 10. Den natürlichen Logarithmus bekommst du über LN(x). Mit zwei Argumenten – LOG(b, x) – wird der Logarithmus zur Basis b berechnet. (Das weicht von vielen Programmiersprachen ab, in denen log für den natürlichen Logarithmus steht – die SQL-Konvention hat sich hier durchgesetzt.)
• SQRT einer negativen Zahl liefert NULL zurück, keinen Fehler.
• POWER(0, 0) ergibt per Konvention 1.

Praktisch wird das überall dort, wo geometrische oder exponentielle Berechnungen ins Spiel kommen: Zinseszinsen, Normalisierung auf Dezibel, Distanzberechnungen und so weiter.

Zufallszahlen mit RANDOM und RANDOMBLOB

RANDOM() liefert einen vorzeichenbehafteten 64-Bit-Integer aus dem kompletten Wertebereich:

SELECT
    RANDOM()                          AS raw_random,
    ABS(RANDOM()) % 100               AS zero_to_99,
    ABS(RANDOM()) % 100 + 1           AS one_to_100,
    ABS(RANDOM() / 9223372036854775807.0) AS unit_interval;

Um eine Zahl in einem bestimmten Bereich zu bekommen, packst du RANDOM() in ABS ein (da RANDOM() vorzeichenbehaftet ist) und verwendest %. Für eine Fließkommazahl zwischen 0 und 1 teilst du das Ergebnis durch den maximalen 64-Bit-Integer. SQLite bringt nämlich keine eingebaute RAND()-Funktion mit, die 0–1 liefert – das musst du dir selbst zusammenbauen.

RANDOMBLOB(n) gibt n zufällige Bytes zurück und ist praktisch, um Session-Tokens oder Testdaten zu erzeugen. Kombiniert mit HEX() bekommst du einen druckbaren String:

SELECT HEX(RANDOMBLOB(8)) AS token;

Jeder Aufruf liefert einen neuen Wert. Verlasse dich also nicht darauf, dass RANDOM() innerhalb derselben Zeile zweimal dieselbe Zahl zurückgibt – selbst innerhalb eines einzigen Ausdrucks ist jeder Aufruf für sich unabhängig.

Alles zusammen in einem Beispiel

Ein kleines durchgerechnetes Beispiel: Entfernungen berechnen und Preise runden für eine Produkttabelle.

CREATE TABLE products (id INTEGER, name TEXT, price_cents INTEGER, weight_g REAL);
INSERT INTO products VALUES
    (1, 'Tasse',     1299, 350.5),
    (2, 'Notizbuch', 850, 180.2),
    (3, 'Stift',      199,  12.0);

SELECT
    name,
    ROUND(price_cents / 100.0, 2)  AS price_dollars,
    CEIL(weight_g / 100)           AS weight_buckets_100g,
    POWER(weight_g, 0.5)           AS sqrt_weight
FROM products;

Der entscheidende Trick steckt in price_cents / 100.0 — das .0 erzwingt eine Division mit Fließkommazahlen, und ROUND bringt das Ergebnis dann auf zwei Nachkommastellen. Ohne den Punkt würde 1299 / 100 schlicht 12 liefern, nicht 12.99.

Weiter geht's mit Datum und Zeit

Mit den numerischen Funktionen ist die Mathematik abgedeckt. Für Datum und Uhrzeit braucht es aber eigenes Werkzeug — SQLite legt solche Werte als Text, Real oder Integer ab und stellt dafür ein überschaubares, aber durchaus mächtiges Set an Funktionen zum Parsen, Formatieren und Rechnen bereit. Genau darum geht es im nächsten Abschnitt.