Amazon Redshift: Complete Gids 2025

-- TYPISCHE CLUSTER STRUCTUUR

┌─────────────────────────────────────┐
│         LEADER NODE                 │
│  Query planning, metadata, parsing  │
│  Distribueert werk naar compute     │
└──────────────┬──────────────────────┘
               │
       ┌───────┴───────┐
       ▼               ▼
┌────────────┐   ┌────────────┐
│ COMPUTE 1  │   │ COMPUTE 2  │
│ Slice 0    │   │ Slice 2    │
│ Slice 1    │   │ Slice 3    │
│ (RA3→S3)   │   │ (RA3→S3)   │
└────────────┘   └────────────┘

-- RA3: data in managed S3 (onbeperkte opslag)
-- DC2: data in lokale NVMe SSD (max 326 TB)
-- Serverless: AWS beheert nodes volledig

-- KOLOM-OPSLAG VOORDEEL:
-- SELECT SUM(bedrag) FROM orders
-- → leest ALLEEN kolom 'bedrag', niet hele rijen
-- → 10-100x minder I/O dan row-based opslag

-- FACT TABEL: gebruik DISTKEY op meest-gejoinde kolom
CREATE TABLE dw.fact_verkoop (
    verkoop_id   BIGINT IDENTITY(1,1),
    klant_id     INTEGER NOT NULL     DISTKEY,   -- verdeelt data gelijkmatig
    product_id   INTEGER NOT NULL,
    datum        DATE NOT NULL         SORTKEY,   -- meest gefilterde kolom
    bedrag       DECIMAL(18,2),
    aantal       SMALLINT
)
DISTSTYLE KEY
COMPOUND SORTKEY (datum, klant_id);   -- compound voor range + equality filters

-- DIMENSIE TABEL: gebruik DISTSTYLE ALL voor kleine tabellen
CREATE TABLE dw.dim_klant (
    klant_id     INTEGER PRIMARY KEY,
    naam         VARCHAR(255),
    segment      VARCHAR(50),
    regio        VARCHAR(100)
)
DISTSTYLE ALL;   -- kopie op élke node → snelle joins, geen data movement

-- QUERY VOORBEELD: zo min mogelijk data movement
SELECT
    k.regio,
    k.segment,
    DATE_TRUNC('month', v.datum) AS maand,
    SUM(v.bedrag)                 AS totaal_omzet,
    COUNT(*)                      AS aantal_orders
FROM dw.fact_verkoop v
JOIN dw.dim_klant k USING (klant_id)
WHERE v.datum BETWEEN '2025-01-01' AND '2025-12-31'
GROUP BY 1, 2, 3
ORDER BY maand;

-- COPY vanuit S3 — paralleliseert automatisch over alle nodes
COPY dw.fact_verkoop
FROM 's3://mijn-bucket/verkoop/2025/'
IAM_ROLE 'arn:aws:iam::123456789:role/RedshiftS3Role'
FORMAT AS PARQUET
-- of: CSV DELIMITER ',' IGNOREHEADER 1 GZIP
STATUPDATE ON
COMPUPDATE ON;

-- VACUUM na bulk loads: resort data en verwijder ghost rows
VACUUM dw.fact_verkoop TO 90 PERCENT;   -- hersorteert tot 90% gesorteerd
ANALYZE dw.fact_verkoop;                 -- update statistieken voor query planner

-- UNLOAD naar S3 voor export / data lake
UNLOAD ('SELECT * FROM dw.fact_verkoop WHERE datum >= ''2025-01-01''')
TO 's3://mijn-bucket/export/verkoop_'
IAM_ROLE 'arn:aws:iam::123456789:role/RedshiftS3Role'
FORMAT PARQUET
PARTITION BY (datum)
MAXFILESIZE 256 MB
PARALLEL ON;

-- RUNNING TOTALS + RANKING in één pass
SELECT
    klant_id,
    datum,
    bedrag,
    SUM(bedrag)  OVER (PARTITION BY klant_id
                       ORDER BY datum
                       ROWS UNBOUNDED PRECEDING)  AS cumulatief,
    LAG(bedrag, 1, 0) OVER (PARTITION BY klant_id ORDER BY datum) AS vorig_bedrag,
    RANK()        OVER (PARTITION BY DATE_TRUNC('month', datum)
                       ORDER BY bedrag DESC)       AS rang_in_maand
FROM dw.fact_verkoop
WHERE datum >= '2025-01-01';

-- MATERIALIZED VIEW voor herhaalde zware queries (Redshift ondersteunt auto-refresh)
CREATE MATERIALIZED VIEW mv_maandelijkse_omzet
AUTO REFRESH YES
AS
SELECT
    DATE_TRUNC('month', datum) AS maand,
    SUM(bedrag)               AS omzet,
    COUNT(DISTINCT klant_id)  AS unieke_klanten
FROM dw.fact_verkoop
GROUP BY 1;

-- STAP 1: Externe schema aanmaken (koppelt aan AWS Glue Data Catalog)
CREATE EXTERNAL SCHEMA spectrum_archive
FROM DATA CATALOG
DATABASE 'mijn_data_lake'
IAM_ROLE 'arn:aws:iam::123456789:role/RedshiftSpectrumRole'
CREATE EXTERNAL DATABASE IF NOT EXISTS;

-- STAP 2: Externe tabel definieëren (verwijst naar S3 partities)
CREATE EXTERNAL TABLE spectrum_archive.fact_verkoop_historisch (
    klant_id  INT,
    datum     DATE,
    bedrag    DECIMAL(18,2),
    regio     VARCHAR(100)
)
PARTITIONED BY (jaar INT, maand INT)
STORED AS PARQUET
LOCATION 's3://mijn-data-lake/verkoop/historisch/'
TABLE PROPERTIES ('compression'='snappy');

-- STAP 3: Gecombineerde query (Redshift + S3 data)
SELECT
    'live'     AS bron,
    SUM(bedrag) AS omzet
FROM dw.fact_verkoop                          -- Redshift tabel (warm)
WHERE datum >= '2024-01-01'
UNION ALL
SELECT
    'archief'  AS bron,
    SUM(bedrag) AS omzet
FROM spectrum_archive.fact_verkoop_historisch  -- S3 Parquet (cold)
WHERE jaar BETWEEN 2020 AND 2023;             -- partition pruning bespaart kosten!

-- STAP 1: Model trainen (Redshift AutoML via SageMaker Autopilot)
CREATE MODEL ml.klant_churn_model
FROM (
    SELECT
        klant_id,
        aantal_orders_afgelopen_90d,
        gemiddeld_orderwaarde,
        dagen_sinds_laatste_order,
        aantal_klachten,
        is_opgezegd           -- TARGET variabele (0/1)
    FROM dw.klant_kenmerken
    WHERE datum_snapshot = '2025-01-01'
)
TARGET is_opgezegd
FUNCTION ml.predict_churn
IAM_ROLE 'arn:aws:iam::123456789:role/RedshiftMLRole'
SETTINGS (
    S3_BUCKET 'mijn-ml-bucket',
    MAX_RUNTIME 7200   -- max 2 uur trainen
);

-- STAP 2: Model toepassen op nieuwe klanten
SELECT
    klant_id,
    naam,
    ml.predict_churn(
        aantal_orders_afgelopen_90d,
        gemiddeld_orderwaarde,
        dagen_sinds_laatste_order,
        aantal_klachten
    ) AS churn_kans
FROM dw.actieve_klanten
WHERE ml.predict_churn(
        aantal_orders_afgelopen_90d,
        gemiddeld_orderwaarde,
        dagen_sinds_laatste_order,
        aantal_klachten
    ) > 0.7   -- klanten met >70% churn kans
ORDER BY churn_kans DESC
LIMIT 100;

-- 1. KIES DE JUISTE DISTKEY (meest-gejoinde kolom, hoge kardinaliteit)
DISTKEY (klant_id)   -- ✅ hoge kardinaliteit, veel gebruikt in joins
DISTKEY (status)     -- ❌ lage kardinaliteit → data skew

-- 2. GEBRUIK COMPOUND vs INTERLEAVED SORTKEY
-- Compound: efficiënt voor range queries op leading column
COMPOUND SORTKEY (datum, regio)   -- ✅ WHERE datum >= '2025-01-01'
-- Interleaved: gelijkmatig voor meerdere kolommen (maar duurder VACUUM)
INTERLEAVED SORTKEY (datum, klant_id, product_id)  -- gebruik spaarzaam

-- 3. COMPRESSIE: gebruik ENCODE AUTO of test met ANALYZE COMPRESSION
ANALYZE COMPRESSION dw.fact_verkoop;
-- Redshift raadt de beste encoding aan per kolom

-- 4. WLM (Workload Management): voorkom dat één query alles blokkeert
-- Stel queue in via console: separate queues voor ETL vs BI queries

-- 5. MATERIALIZED VIEWS voor herhaalde aggregaties
CREATE MATERIALIZED VIEW mv_dagomzet AUTO REFRESH YES AS
    SELECT datum, SUM(bedrag) FROM dw.fact_verkoop GROUP BY datum;

-- 6. RESULT CACHE: identieke queries worden gecached (gratis)
-- Actief by default, werkt voor ongewijzigde tabellen

-- 7. AQUA (Advanced Query Accelerator): automatisch voor RA3 nodes
-- Verplaatst rekenkracht naar storage laag, tot 10x sneller

-- 8. VACUUM regelmatig uitvoeren na DELETE/UPDATE
VACUUM DELETE ONLY dw.fact_verkoop;  -- snel: verwijdert alleen ghost rows
VACUUM FULL dw.fact_verkoop;          -- langzaam: hersorteer + delete

-- 9. QUERY MONITORING via STL/SVL views
SELECT query, TRIM(querytxt), starttime, elapsed
FROM stl_query
WHERE elapsed > 60000000   -- queries langer dan 60 seconden
ORDER BY elapsed DESC
LIMIT 10;

-- 10. GEBRUIK LATE BINDING VIEWS voor flexibele schema-evolutie
CREATE VIEW vw_verkoop_huidig AS
SELECT * FROM dw.fact_verkoop
WITH NO SCHEMA BINDING;   -- view breekt niet bij tabelwijzigingen

-- AWS Console → Redshift → Serverless → Get Started
-- Of via AWS CLI:

aws redshift-serverless create-namespace \
    --namespace-name mijn-datawarehouse \
    --admin-username admin \
    --admin-user-password 'MijnWachtwoord123!' \
    --db-name analytics

aws redshift-serverless create-workgroup \
    --workgroup-name mijn-werkgroep \
    --namespace-name mijn-datawarehouse \
    --base-capacity 8 \   -- minimale RPU (gratis tier = 300 RPU-uur/maand)
    --publicly-accessible false

-- Direct in AWS Console via Query Editor v2 (geen client nodig!)
-- Of via Python/psycopg2:

import psycopg2

conn = psycopg2.connect(
    host="mijn-werkgroep.123456789.eu-west-1.redshift-serverless.amazonaws.com",
    port=5439,
    dbname="analytics",
    user="admin",
    password="MijnWachtwoord123!",
    sslmode="require"
)

-- Of via SQLAlchemy (voor dbt, pandas, enz.):
-- pip install sqlalchemy-redshift psycopg2-binary
from sqlalchemy import create_engine
engine = create_engine(
    "redshift+psycopg2://admin:wachtwoord@host:5439/analytics"
)

-- Maak IAM role aan met S3 leesrechten en koppel aan Redshift

-- Maak tabel aan
CREATE TABLE verkoop (
    order_id  INTEGER,
    datum     DATE,
    bedrag    DECIMAL(10,2),
    klant_id  INTEGER
);

-- Laad vanuit S3 CSV
COPY verkoop
FROM 's3://mijn-bucket/verkoop.csv'
IAM_ROLE DEFAULT
CSV IGNOREHEADER 1;

-- Klaar! Eerste query:
SELECT DATE_TRUNC('month', datum), SUM(bedrag)
FROM verkoop
GROUP BY 1 ORDER BY 1;