Hvad er skemaer i PostgreSQL?

Question

Accepted Answer

Et **skema** i PostgreSQL er et **namespace** inden for en database — en logisk beholder, der grupperer relaterede tabeller, visninger, funktioner og andre objekter. Skemaer lader dig organisere objekter og undgå navnekollisioner; standardskemaet er `public`.

## Skemaer organiserer objekter inden for en database

```text
A PostgreSQL server can have multiple DATABASES.
Each database can have multiple SCHEMAS (namespaces).
Each schema contains TABLES, views, functions, etc.
→ Hierarchy: server → database → schema → tables/objects
```

```sql
CREATE SCHEMA sales;                    -- create a schema
CREATE TABLE sales.orders (...);         -- a table IN the sales schema (qualified name)
SELECT * FROM sales.orders;              -- reference with schema.table

-- the default schema is `public` — unqualified objects go there
CREATE TABLE users (...);                -- actually public.users
```

Objekter refereres som `schema.object`. Uden et skemaprefix bruger Postgres **søgestien** (standard: `public`).

## Søgestien

```sql
SHOW search_path;                        -- default: "$user", public
SET search_path TO sales, public;        -- look in sales first, then public
SELECT * FROM orders;                    -- finds sales.orders (no prefix needed)
```

**Søgestien** bestemmer, hvilke skemaer Postgres leder i efter ukvalificerede navne — ved at sætte den kan du bruge korte navne inden for et valgt skema.

## Hvorfor bruge skemaer

```text
✓ ORGANIZATION — group related objects (e.g. `sales`, `inventory`, `auth` schemas)
✓ Avoid naming collisions — two schemas can each have an `orders` table
✓ MULTI-TENANCY — a schema per tenant (isolating each customer's data)
✓ SECURITY/permissions — grant access per schema
✓ Separating concerns — e.g. an `app` schema vs an `analytics` schema
```

Et almindeligt mønster er et **skema pr. lejer** i multi-lejer-applikationer, eller gruppering efter domæne/modul.

## Hvorfor det betyder noget

Skemaer er en nyttig PostgreSQL-funktion til **organisering af databaseobjekter**, og det er værdifuldt at forstå dem for at strukturere databaser godt, især når de vokser eller betjener flere lejere.

At forstå, at et skema er et namespace inden for en database (gruppering af tabeller, visninger, funktioner) — med hierarkiet server → database → skema → objekter — præciserer, hvordan Postgres organiserer objekter, og hvordan man refererer til dem (`schema.object`, eller ved at stole på **søgestien** for ukvalificerede navne, som som standard er `public`).

At kende til de **praktiske anvendelser** er nøgleværdien: skemaer giver organisation (gruppering af relaterede objekter efter domæne/modul — `auth`, `sales`, `analytics`), undgår navnekollisioner (forskellige skemaer kan have samme navngivne tabeller), muliggør sikkerhed/tilladelser pr. skema, og er crucialdt for at understøtte **multi-tenancy** (et almindeligt mønster af ét skema pr. lejer for at isolere hver kundes data — en vigtig arkitekturmulighed for SaaS-applikationer).

At forstå skemaer og søgestien hjælper dig med at organisere en database rent, undgå rottet og kollisioner ved at putte alt i `public`, og implementere mønstre som multi-tenancy.

Eftersom det betyder noget at organisere databaseobjekter logisk for vedligeholdelse (især i større applikationer), og da skemaer muliggør vigtige mønstre (domæneopskillelse, multi-tenancy, sikkerhed pr. skema), er det værdifuldt, praktisk relevant viden at forstå PostgreSQL-skemaer — hvad de er, søgestien, og deres praktiske anvendelser — til effektiv strukturering af Postgres-databaser, især relevant for større eller multi-lejer-applikationer, hvor god objektorganisering er vigtig.