Wat zijn schemas in PostgreSQL?

Question

Accepted Answer

Een **schema** in PostgreSQL is een **namespace** binnen een database — een logische container die gerelateerde tabellen, views, functies en andere objecten groepeert. Schemas stellen je in staat om objecten te organiseren en naamgevingsconflicten te voorkomen; het standaardschema is `public`.

## Schemas organiseren objecten binnen een 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
```

Objecten worden aangeduid als `schema.object`. Zonder schemaprefix gebruikt Postgres het **search path** (standaard: `public`).

## Het search path

```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)
```

Het **search path** bepaalt in welke schemas Postgres zoekt naar ongelimiteerde namen — door het in te stellen kun je korte namen gebruiken binnen een gekozen schema.

## Waarom schemas gebruiken

```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
```

Een veelgebruikt patroon is een **schema per tenant** in multi-tenant-applicaties, of groepering op domein/module.

## Waarom het belangrijk is

Schemas zijn een nuttige PostgreSQL-functie voor het **organiseren van database-objecten**, en het begrijpen ervan is waardevol voor het goed structureren van databases, vooral naarmate ze groeien of meerdere tenants bedienen.

Begrijpen dat een schema een namespace binnen een database is (groeperend tabellen, views, functies) — met de hiërarchie server → database → schema → objecten — verduidelijkt hoe Postgres objecten organiseert en hoe je ernaar verwijst (`schema.object`, of vertrouwend op het **search path** voor ongelimiteerde namen, standaard naar `public`).

Het kennen van de **praktische toepassingen** is de kernwaarde: schemas bieden organisatie (gerelateerde objecten groeperen op domein/module — `auth`, `sales`, `analytics`), voorkomen naamgevingsconflicten (verschillende schemas kunnen tabellen met dezelfde naam hebben), maken per-schema beveiliging/machtigingen mogelijk, en ondersteunen cruciaal **multi-tenancy** (een veelgebruikt patroon van één schema per tenant om de data van elke klant te isoleren — een belangrijk architectuuroptie voor SaaS-applicaties).

Begrijpen van schemas en het search path helpt je een database schoon te organiseren, de rommel en conflicten van alles in `public` plaatsen te voorkomen, en patronen als multi-tenancy toe te passen.

Omdat het logisch organiseren van database-objecten van belang is voor onderhoudbarheid (vooral in grotere applicaties), en omdat schemas belangrijke patronen mogelijk maken (domeinscheiding, multi-tenancy, per-schema beveiliging), is het begrijpen van PostgreSQL schemas — wat ze zijn, het search path, en hun praktische toepassingen — waardevol, praktisch relevant kennis voor het effectief structureren van Postgres-databases, met name relevant voor grotere of multi-tenant-applicaties waar goede objectorganisatie belangrijk is.