Vilka är vanliga SQL-datatyper och hur väljer du dem?

Question

Accepted Answer

Varje kolumn har en **datatyp** som definierar vad den lagrar — siffror, text, datum, booleanar, osv. Att välja rätt typ är viktigt för **lagringseffektivitet, korrekthet och prestanda**. Typer varierar något mellan databaser, men kategorierna är standard.

## Numeriska typer

```sql
INT / INTEGER          -- whole numbers (4 bytes)
BIGINT                 -- large whole numbers (8 bytes) — for IDs that grow large
SMALLINT               -- small whole numbers (save space)
DECIMAL(10,2) / NUMERIC -- EXACT decimal — use for MONEY (no rounding errors)
FLOAT / REAL / DOUBLE  -- approximate floating point — NOT for money
SERIAL / AUTO_INCREMENT -- auto-incrementing integer (for primary keys)
```

**Viktigt:** använd **`DECIMAL`/`NUMERIC` för pengar** (exakt aritmetik), aldrig `FLOAT`/`DOUBLE` (som har avrundningsfel som skadar finansiella beräkningar).

## Texttyper

```sql
VARCHAR(n)    -- variable-length text up to n chars (the common choice)
CHAR(n)       -- FIXED-length (padded) — for codes of known length (e.g. country codes)
TEXT          -- large/unlimited text (articles, descriptions)
```

`VARCHAR(n)` är den vanliga texttypen; `TEXT` för stort innehål; `CHAR(n)` för kod med fast längd.

## Datum/tid, boolean och andra

```sql
DATE           -- date only (2024-01-15)
TIME           -- time only
TIMESTAMP      -- date + time (with or WITHOUT time zone — TIMESTAMPTZ in Postgres)
BOOLEAN        -- true/false
UUID           -- universally unique identifier (good for distributed IDs)
JSON / JSONB   -- structured JSON data (JSONB in Postgres is indexed/efficient)
BLOB / BYTEA   -- binary data
```

## Varför det är viktigt att välja rätt typ

```text
✓ Storage — smaller types use less space (INT vs BIGINT; VARCHAR vs TEXT)
✓ Correctness — DECIMAL for money (exact), proper date types for dates, BOOLEAN for flags
✓ Performance — correct types index and compare efficiently; right size = less I/O
✓ Validation — the type itself constrains what can be stored (an INT can't hold text)
✓ Time zones — use TIMESTAMPTZ for timestamps to avoid time-zone bugs
```

## Varför det spelar roll

Att välja lämpliga datatyper är en grundläggande aspekt av databasdesign som påverkar **lagring, korrekthet och prestanda**, så att förstå de vanliga typerna och hur man väljer dem är viktig kunskap för vardagen.

Att känna till kategorierna — numerisk (INT, BIGINT, DECIMAL, FLOAT), text (VARCHAR, CHAR, TEXT), datum/tid (DATE, TIMESTAMP), boolean och specialtyper (UUID, JSON/JSONB) — är nödvändigt för att designa tabeller korrekt.

Flera val har verkliga konsekvenser som är värda att förstå: att använda **`DECIMAL`/`NUMERIC` för pengar** istället för `FLOAT` (en kritisk korrekthetsaspekt — avrundningsfel i flyttal skadar finansiella beräkningar, ett klassiskt, allvarligt fel), att välja rätt **heltalsstorlek** (`BIGINT` för ID:n som kan växa bortom INT:s intervall — ett verkligt problem för stora tabeller), att använda korrekta **datum/tid-typer** (särskilt tidszons-medvetna `TIMESTAMPTZ` för att undvika tidszonfel), och att välja lämpligt stora texttyper (VARCHAR vs TEXT).

Rätt typval påverkar lagringseffektivitet (mindre typer använder mindre utrymme och I/O), korrekthet (typen validerar och representerar data exakt) och prestanda (korrekta typer indexerar och jämför effektivt).

Eftersom varje kolumn kräver ett typval, och eftersom felaktiga val orsakar verkliga problem (FLOAT för pengar som skadar beräkningar, INT-överflöde för ID:n, tidszonfel), är förståelse för vanliga SQL-datatyper och principerna för att välja dem — exakthet för pengar, lämplig storlek, tidszons-medvetna tidsstämplar — viktig, grundläggande kunskap för sund databasdesign som förebygger en klass av subtila men allvarliga datakorrekthet och prestandaproblem.