PostgreSQL / EDB

Postgres to nie tylko OLTP – budujemy hurtownię danych z dbt

2026-07-20
Podziel się

Czy PostgreSQL może pełnić rolę hurtowni danych, zanim zaczniesz inwestować w Snowflake’a, BigQuery czy Databricks? W wielu mniejszych i średnich projektach odpowiedź brzmi: tak – pod warunkiem że odpowiednio uporządkujesz modele, logikę biznesową i sposób wykonywania zapytań. W tym artykule pokazujemy krok po kroku, jak za pomocą dbt zbudować w Postgresie schemat gwiazdy, warstwę stagingową i gotowy model raportowy, który zastąpi wielokrotnie powtarzane, rozbudowane zapytania SQL. Dowiesz się również, jak odseparować analitykę od danych aplikacyjnych, wdrożyć testy jakości i przygotować architekturę, którą w przyszłości łatwo przeniesiesz do dedykowanej hurtowni.

Wyobraź sobie taką sytuację: Twój system e-commerce w Postgresie działa świetnie, dopóki dział marketingu nie prosi o raport „sprzedaży produktów w podziale na kategorie i regiony z ostatnich 6 miesięcy”. Zaczynasz pisać zapytanie. Jeden join, drugi, piąty… nagle masz 200 linii SQL-a, które wykonują się wieczność, a jeden błąd w WHERE sprawia, że liczby się nie zgadzają.

To klasyczny problem analitycznego długu technicznego – ale jego rozwiązaniem nie zawsze jest „wyniesienie” ciężkich zapytań poza Postgresa. dbt to wciąż tylko zestaw zapytań SQL wykonywanych na tej samej bazie co aplikacja – żadnej magii tu nie ma. Różnica polega na tym, kiedy i jak często te zapytania się wykonują. Zamiast odpalać 200-liniowy join przy każdym odświeżeniu dashboardu (albo przy każdym pytaniu ad hoc analityka), uruchamiamy je raz, zgodnie z harmonogramem. Budujemy Star Schema, a na jego szczycie gotowy model raportowy, który BI może odpytywać bez każdorazowego składania joinów i bez 200 linii SQL-a za każdym razem.

Dwie uwagi na start. Po pierwsze: zakres. W żargonie ETL/ELT zajmujemy się tu wyłącznie literą T (transformacja) – surowe dane są już w Postgresie, bo aplikacja wrzuca je tam na bieżąco, więc Extract i Load masz z głowy. To zresztą bardziej ELT niż ETL: w dbt transformacja dzieje się po załadowaniu, prosto w bazie, a nie gdzieś po drodze. Po drugie: obciążenie. To nadal ta sama instancja Postgresa – różnica polega na tym, że obciążenie jest skoncentrowane w jednym, kontrolowanym oknie czasowym, a nie rozproszone między przypadkowe zapytania całego zespołu analitycznego. W dalszej części pokażemy, jak uporządkować tę warstwę za pomocą osobnego schematu oraz jak zaplanować harmonogram, aby ograniczyć wpływ transformacji na aplikację.

Spis treści:

Dlaczego Star Schema?

Masz piętrowe joiny, 200 linii SQL-a i liczby, które się nie zgadzają? Star Schema (schemat gwiazdy) pomaga ten problem ograniczyć, bo porządkuje model danych i zmniejsza liczbę miejsc, w których powstaje logika raportowa. To fundamentalny model architektury danych stosowany w hurtowniach danych. Jego istotą jest podział danych na centralną tabelę faktów, zawierającą mierzalne dane ilościowe przypisane do konkretnych zdarzeń biznesowych (np. kwoty poszczególnych transakcji sprzedaży), oraz zestaw połączonych z nią bezpośrednio, zdenormalizowanych tabel wymiarów, które przechowują atrybuty opisowe (np. czas, lokalizację czy dane o produkcie). Taka budowa minimalizuje liczbę niezbędnych złączeń (joinów), co przy właściwym modelu, indeksach i wolumenie może wyraźnie skrócić czas generowania raportów w narzędziach Business Intelligence. Dodatkowo sprawia, że struktura bazy staje się intuicyjna i łatwa w nawigacji dla analityków biznesowych.

Zanim przejdziemy do kodu, podsumujmy, co to konkretnie zmienia w naszej sytuacji z wstępu:

  • wydajność: Star Schema minimalizuje liczbę joinów przy agregacjach – koniec z piętrowymi joinami z przykładu ze wstępu;
  • Single Source of Truth: definiujesz logikę biznesową (np. co to jest „aktywne zamówienie”) w jednym miejscu – koniec z liczbami, które „się nie zgadzają” w zależności od tego, kto pisał zapytanie;
  • czytelność: zamiast jednej tabeli-potwora z 80 kolumnami, masz jasny podział na fakty (zdarzenia) i wymiary (kontekst).

Dlaczego Postgres? Baza, którą już masz

W świecie Big Data wszyscy krzyczą: „Snowflake!”, „BigQuery!”, „Databricks!”. Ale dla wielu projektów scale-up Postgres jest w zupełności wystarczający – szczególnie gdy wolumeny danych liczone są w gigabajtach, a nie terabajtach. Dlaczego warto przy nim zostać?

  • Zerowy koszt wejścia: jeśli Twoja aplikacja już na nim stoi, nie musisz konfigurować nowych usług, VPC, uprawnień czy dodatkowych płatności. Wykorzystujesz infrastrukturę, którą już znasz.
  • Indeksowanie: w Postgresie masz pełną kontrolę nad indeksami (B-tree, GIN, BRIN). Dobrze zindeksowany Star Schema – np. B-tree na kluczach wymiarów i BRIN na kolumnie daty w tabeli faktów – może znacząco skrócić czas odpowiedzi dla typowych, selektywnych zapytań BI (konkretny zakres dat, konkretna kategoria czy klient). Realny wynik zależy jednak od wolumenu danych, selektywności filtrów, sprzętu, cache, współbieżności i planu zapytania.
  • Ekosystem: narzędzia takie jak pg_stat_statements czy EXPLAIN ANALYZE pozwalają Ci debugować wydajność zapytań budujących Twoją hurtownię dokładnie tak samo, jak zapytania Twojej aplikacji – nie musisz uczyć się nowego zestawu narzędzi do monitoringu.

Dlaczego dbt? SQL z procesem inżynierskim

Jeśli myślisz, że dbt to tylko „nakładka na SQL-a„, to… masz rację, ale to nakładka, która zmienia zasady gry. Magii dalej tu nie ma – jest za to porządny proces inżynierski wokół tych samych zapytań SQL.

  • Version Control (Git): logika Twoich danych nie żyje już w ukrytych procedurach składowanych (Stored Procedures) czy widokach tworzonych „z palca”. To kod, który przechodzi Code Review.
  • Lineage (Rodowód danych): dbt automatycznie generuje graf zależności (DAG). Widzisz czarno na białym, która tabela faktu zależy od którego stagingu. Koniec z pytaniem: „Co się zepsuje, jak zmienię tę kolumnę?”.
  • Koniec z „czarną magią” funkcji i triggerów: w tradycyjnym podejściu do transformacji w Postgresie często lądujemy w pułapce procedur składowanych (Stored Procedures) i skomplikowanych funkcji. dbt wyciąga tę logikę z „bebechów” bazy danych i wrzuca ją tam, gdzie jej miejsce: do porządnego repozytorium kodu.
  • Jinja Templating: możesz używać pętli i instrukcji warunkowych wewnątrz SQL-a. Potrzebujesz wygenerować podobny model dla każdego kraju? W dbt zrobisz to pętlą {% for country in countries %}.
  • Wbudowane środowiska: dbt ułatwia separację środowisk. Przy dobrze skonfigurowanych targetach i bez hardcodowania schematów w modelach komenda dbt run na Twoim laptopie stworzy tabele w Twoim schemacie deweloperskim (u nas dev_analytics), a na CI/CD ten sam kod SQL może trafić do środowiska produkcyjnego.

Zanim zaczniemy: konfiguracja, izolacja i harmonogram

Tutorial zakłada, że masz już bazę Postgres z surowymi tabelami orders, users i products. Zanim przejdziemy do budowy modeli, zainstalujemy dbt, skonfigurujemy połączenie, określimy założenia dotyczące danych źródłowych i przygotujemy sposób uruchamiania transformacji tak, aby ograniczyć ich wpływ na produkcję.

Instalacja dbt i inicjalizacja projektu

pip install dbt-postgres
dbt init analytics_project

Polecenie dbt init zapyta o dane do połączenia i utworzy katalog projektu razem z plikiem profiles.yml (domyślnie w ~/.dbt/). Tworzy ono również przykładowy katalog models/example/ z dwoma modelami demonstracyjnymi – usuń go, zanim ruszysz dalej, inaczej dbt run zbuduje te dodatkowe modele i wynik nie będzie się zgadzał z tym, co pokazujemy w kroku 7:

rm -r analytics_project/models/example

Wejdź do katalogu projektu i przygotuj foldery na modele z tutoriala:

cd analytics_project
mkdir -p models/staging models/marts

W tym tutorialu zostawiamy domyślny dbt_project.yml; modele trzymamy w models/staging i models/marts, a packages.yml dodajemy w głównym katalogu projektu.

Struktura danych źródłowych

Żeby przykład był jednoznaczny, przyjmijmy minimalny kontrakt danych źródłowych. Typy dopasuj do własnej aplikacji, ale kluczowe są: zgodne typy kluczy, niepuste created_at/updated_at, dodatnia kwota zamówienia oraz słownik statusów zawierający np. completed i refunded. W tym uproszczonym modelu amount oznacza dodatnią wartość zamówienia; zwroty reprezentujemy statusem, nie ujemną kwotą.

create table public.users (
    id bigint primary key,
    email text not null,
    country text,
    created_at timestamp not null
);

create table public.products (
id bigint primary key,
name text not null,
category text,
price numeric(12,2)
);

create table public.orders (
id bigint primary key,
user_id bigint not null references public.users(id),
product_id bigint not null references public.products(id),
amount numeric(12,2) not null,
status text not null,
created_at timestamp not null,
updated_at timestamp not null
);

Izolacja od produkcji – schemat analityczny

Najprostszym sposobem na to, by nie „dotykać” danych produkcyjnych, jest skierowanie dbt do osobnego schematu w tej samej bazie (np. analytics), a nie do public. Jeśli masz taką możliwość, jeszcze lepszym rozwiązaniem jest podłączenie dbt do read repliki – wtedy nawet ciężkie zapytania SELECT nie wpłyną na wydajność środowiska PostgreSQL.

Przykładowy profiles.yml:

analytics_project:
  target: dev
  outputs:
    dev:
      type: postgres
      host: localhost      # lub adres read repliki
      user: dbt_user
      password: "{{ env_var('DBT_PASSWORD') }}"
      port: 5432
      dbname: shop_db
      schema: dev_analytics
      threads: 4
    prod:
      type: postgres
      host: localhost
      user: dbt_user
      password: "{{ env_var('DBT_PASSWORD') }}"
      port: 5432
      dbname: shop_db
      schema: analytics       # produkcyjny schemat analityczny
      threads: 4

Zwróć uwagę na {{ env_var('DBT_PASSWORD') }}: w tej formie dbt wymaga, by zmienna środowiskowa była ustawiona, w przeciwnym razie dbt run zakończy się błędem Env var required but not provided. Przed pierwszym uruchomieniem wyeksportuj hasło w swojej sesji:

export DBT_PASSWORD='twoje_haslo'   # Linux / macOS
# w PowerShell: $env:DBT_PASSWORD = 'twoje_haslo'

(Jeśli wolisz, żeby brak zmiennej nie blokował lokalnego dev, możesz podać wartość domyślną: env_var('DBT_PASSWORD', 'haslo_dev') – ale rób tak wyłącznie dla środowiska deweloperskiego, nigdy dla produkcji.)

Tabele source (czyli orders, users, products) wciąż wskazują na schemat public, ale wszystkie modele dbt – staging, wymiary, fakty – będą tworzone w dev_analytics (lokalnie, target dev) lub analytics (na produkcji, dzięki ustawieniu schema: analytics w targecie prod). Wystarczy uruchomić dbt z wybranym targetem (dbt run --target prod); ponieważ modele nie nadpisują schematu własną konfiguracją, dbt użyje tego z targetu. Dzięki temu, przy poprawnej konfiguracji targetów i uprawnień, raportowe tabele nie miksują się z tabelami aplikacji, a analitykom można nadać dostęp tylko do schematu analitycznego.

Harmonogram: OLTP w dzień, analityka w nocy

Osobny schemat rozwiązuje problem porządku i uprawnień, ale nie zwalnia z myślenia o obciążeniu serwera – jeśli dbt run odpali się w środku dnia, nadal zużyje CPU, RAM i I/O tej samej instancji Postgresa, z której korzysta aplikacja. Dobrą praktyką jest zaplanowanie pełnych przebudów modeli na godziny nocne lub inne okno o niskim ruchu w aplikacji – np. przez cron, GitHub Actions na harmonogramie albo dedykowany orkiestrator (Airflow, Dagster). Po dużych przebudowach lub incrementalach typu delete+insert warto też monitorować autovacuum i statystyki; w razie potrzeby można zaplanować ANALYZE albo VACUUM ANALYZE, zwłaszcza jeśli planner zaczyna wybierać złe plany zapytań.

W praktyce baza w dzień obsługuje ruch transakcyjny (OLTP), a w nocy – jeśli nie koliduje to z backupami, batchami i innymi procesami utrzymaniowymi – wykonuje cięższe zapytania analityczne i przebudowy modeli dbt. To rozwiązanie nie zastąpi pełnej izolacji (read repliki czy osobnej instancji), ale dla wielu mniejszych i średnich projektów pozwala efektywniej wykorzystać już opłacony serwer, zamiast dublować infrastrukturę, która przez większość czasu pozostawałaby niewykorzystana.

Implementacja: krok po kroku

Załóżmy, że mamy surowe tabele: orders, users i products. Chcemy zbudować schemat gwiazdy z dwoma wymiarami opisowymi (dim_users, dim_products), wymiarem czasu (dim_date) i jedną tabelą faktów (fct_orders). Ten przykład zakłada uproszczony e-commerce, w którym jedno zamówienie dotyczy jednego produktu; w realnych sklepach często właściwą tabelą faktów byłaby raczej fct_order_items z pozycjami zamówienia i kolumną quantity.

Krok 1: Definicja źródeł (Source)

W pliku models/sources.yml definiujemy, skąd dbt ma brać surowe dane.

version: 2
sources:
  - name: raw_data
    schema: public
    tables:
      - name: orders
      - name: users
      - name: products

Krok 2: Warstwa staging

Zanim zbudujemy wymiary i fakty, dobrą praktyką jest stworzenie lekkiej warstwy staging – modeli typu widok (view), które czyszczą nazwy kolumn i są dobrym miejscem na jawne rzutowanie typów. Dzięki temu żaden model w warstwie marts nie odwołuje się bezpośrednio do source – cała logika biznesowa siedzi wyżej, a staging pozostaje prostym, przewidywalnym punktem wejścia.

-- models/staging/stg_users.sql
{{ config(materialized='view') }}

select
id::bigint as user_id,
email::text as email,
country::text as country,
created_at::timestamp as created_at
from {{ source('raw_data', 'users') }}

-- models/staging/stg_products.sql
{{ config(materialized='view') }}

select
id::bigint as product_id,
name::text as product_name,
category::text as category,
price::numeric(12,2) as price -- aktualna cena katalogowa; nieużywana w fct_orders (tam mamy faktyczne `amount` z transakcji),
-- zostaje w stagingu jako baza np. dla przyszłego dim_products z historią cen (SCD typu 2)
from {{ source('raw_data', 'products') }}

-- models/staging/stg_orders.sql
{{ config(materialized='view') }}

select
id::bigint as order_id,
user_id::bigint as user_id,
product_id::bigint as product_id,
amount::numeric(12,2) as amount,
status::text as status,
created_at::timestamp as created_at,
updated_at::timestamp as updated_at -- wymagane do poprawnego incremental w fct_orders, patrz krok 4
from {{ source('raw_data', 'orders') }}

Zakładamy tu, że tabela orders ma kolumnę updated_at, aktualizowaną przy każdej zmianie wiersza (np. triggerem BEFORE UPDATE albo przez ORM aplikacji). To bardzo częsty wzorzec, ale jeśli go u siebie nie masz – musisz go dodać, bo bez niego nie da się sensownie wykryć, że istniejące zamówienie zmieniło status (więcej w kroku 4).

Krok 3: Budowa wymiarów (Dimensions)

Wymiary to tabele typu „kto?”, „co?”, „kiedy?”. Budujemy je na bazie modeli staging, nie source.

dim_users – kontekst klienta. To tutaj trafia kolumna country – w naszym przykładzie z wstępu („sprzedaż w podziale na kategorie i regiony”) to właśnie dim_users.country, połączone z fct_orders przez user_fk, pełni rolę wymiaru geograficznego. Nie potrzebujemy do tego osobnej tabeli dim_region – przy tej skali wystarczy atrybut w dim_users:

-- models/marts/dim_users.sql
{{ config(materialized='table') }}

select
user_id as user_pk,
email,
country,
created_at::date as signup_date,
case
when email like '%@gmail.com' then 'B2C'
else 'B2B'
end as user_segment -- logika biznesowa w jednym miejscu
from {{ ref('stg_users') }}

To oczywiście bardzo uproszczona heurystyka (w realnym projekcie segmentacja B2B/B2C zwykle wynika z pola w systemie, a nie z domeny e-mail) – tutaj służy jedynie jako przykład logiki biznesowej, którą warto trzymać w jednym, testowalnym miejscu, a nie rozsianą po zapytaniach raportowych.

dim_products – kontekst produktu (kluczowy w naszym raporcie „sprzedaż w podziale na kategorie”):

-- models/marts/dim_products.sql
{{ config(materialized='table') }}

select
product_id as product_pk,
product_name,
category
from {{ ref('stg_products') }}

Ten wymiar nie obsługuje historii kategorii ani cen. Jeśli kategoria produktu może zmieniać się w czasie, a raport ma pokazywać stan na moment zamówienia, potrzebujesz historyzacji wymiaru (np. SCD Type 2) albo utrwalenia wybranych atrybutów w tabeli faktów.

dim_date – klasyczny wymiar czasu, niezbędny do raportów typu „ostatnie 6 miesięcy” czy agregacji miesiecznych. Generujemy go za pomocą makra date_spine z pakietu dbt_utils (konfiguracja pakietu w kroku 6, instalacja w kroku 7):

-- models/marts/dim_date.sql
{{ config(materialized='table') }}

with spine as (
{{ dbt_utils.date_spine(
datepart="day",
start_date="cast('2018-01-01' as date)",
end_date="cast(current_date + interval '2 years' as date)"
) }}
)

select
date_day as date_pk,
extract(year from date_day) as year,
extract(month from date_day) as month,
extract(quarter from date_day) as quarter,
trim(to_char(date_day, 'Day')) as day_name -- trim, bo to_char dopełnia nazwę dnia spacjami
from spine

Trzy kwestie warte uwagi:

  • end_date jest liczony dynamicznie jako current_date + interval '2 years', a nie zapisany jako sztywna data. Ponieważ dim_date ma materialized='table', każdy dbt run przebudowuje tabelę od zera – dzięki dynamicznemu end_date zasięg dat „przesuwa się” razem z kalendarzem i nie musisz pamiętać o ręcznym wydłużaniu spine’a. Gdybyś zostawił sztywną datę (np. 2027-01-01), po jej przekroczeniu zamówienia z order_date_fk nowszym niż ta data nie znalazłyby dopasowania w dim_date – a w BI objawiłoby się to jako ciche, niewyjaśnione „gubienie” najnowszych transakcji w raportach po dacie.
  • z tego samego powodu pilnuj dolnej granicy. start_date musi być nie późniejszy niż data najstarszego zamówienia w orders, inaczej historyczne transakcje wypadną poza dim_date – a wtedy test relationships na order_date_fk (krok 6) zwróci błąd przy dbt test. W przykładzie ustawiliśmy 2018-01-01; dopasuj tę datę do swoich danych (albo, analogicznie do end_date, wylicz ją dynamicznie z min(created_at) źródła, jeśli historia bywa starsza).
  • to_char(date_day, 'Day') w Postgresie zwraca nazwę dnia tygodnia dopełnioną spacjami do stałej długości (np. "Monday "), więc trim() jest tu niezbędny, jeśli nie chcesz zdziwienia przy filtrowaniu czy grupowaniu po day_name.

Krok 4: Budowa faktów (Facts)

Fakty to mierzalne zdarzenia. fct_orders łączy klucze obce do wszystkich wymiarów z mierzalnymi wartościami (amount).

-- models/marts/fct_orders.sql
{{ config(
    materialized='incremental',
    unique_key='order_pk',
    indexes=[
      {'columns': ['order_pk'], 'unique': True},
      {'columns': ['user_fk']},
      {'columns': ['product_fk']},
      {'columns': ['order_date_fk'], 'type': 'brin'}
    ]
) }}

select
order_id as order_pk,
user_id as user_fk,        -- klucz obcy do dim_users
product_id as product_fk,  -- klucz obcy do dim_products
created_at::date as order_date_fk, -- klucz obcy do dim_date
amount,
status,
created_at,
updated_at
from {{ ref('stg_orders') }}

{% if is_incremental() %}
-- przetwarzamy nowe ORAZ zmodyfikowane zamówienia (np. zmiana statusu)
where updated_at >= (
select coalesce(max(updated_at), timestamp '1900-01-01') - interval '1 hour'
from {{ this }}
)
{% endif %}

Uwaga na unique_key i strategię incremental: w materializacji incremental parametr unique_key jest kluczowy, ale sam w sobie nie wystarczy. Pierwsza, naiwna wersja tego filtra mogłaby wyglądać tak: where created_at > (select max(created_at) from {{ this }}). Problem: created_at to moment utworzenia zamówienia i nie zmienia się, gdy zamówienie później zmienia status (np. z „completed” na „refunded”). Taki wiersz nigdy ponownie nie przeszedłby przez ten filtr – fct_orders.status zostałby trwale nieaktualny, a unique_key nie miałby nawet szansy zadziałać, bo wiersz nie trafiłby do przetworzenia po raz drugi.

Dlatego filtrujemy po updated_at – kolumnie aktualizowanej przy każdej zmianie wiersza, nie tylko przy jego utworzeniu. W przykładzie dodajemy też małe okno cofające (interval '1 hour'), żeby ograniczyć ryzyko pominięcia rekordów opóźnionych lub zapisanych na granicy poprzedniego uruchomienia. Wielkość tego okna dopasuj do sposobu, w jaki dane trafiają do Postgresa; w systemach z opóźnioną synchronizacją może to być np. 1 dzień. Dzięki temu:

  • nowe zamówienia trafiają do fct_orders (mają nowy updated_at),
  • zamówienia ze zmienionym statusem również trafiają do przetworzenia (ich updated_at jest nowsze niż ostatni dbt run),
  • a unique_key='order_pk' zapewnia, że dbt zaktualizuje istniejący wiersz (w adapterze Postgres dzieje się to domyślnie przez delete starych wierszy i insert nowych w ramach jednej transakcji), zamiast dodać duplikat.

Krótko: unique_key odpowiada za to, co się dzieje, gdy wiersz trafi ponownie do przetworzenia, a filtr po updated_at odpowiada za to, czy w ogóle trafi. Bez obu elementów naraz incremental fakt z czasem może zacząć pokazywać nieaktualne dane. Ten wzorzec zakłada też, że updated_at jest niepuste i wiarygodne – dlatego w kroku 6 dodajemy na tej kolumnie test not_null.

Świadomie użyliśmy tu >=, a nie >. Przy > wiersze o updated_at dokładnie równym dotychczasowemu maksimum (np. kilka zamówień zmienionych w tej samej sekundzie tuż po zakończeniu poprzedniego runu) mogłyby zostać pominięte. >= przetworzy je ponownie, a ponieważ unique_key i tak deduplikuje wiersze, kosztem jest jedynie odświeżenie kilku rekordów z pogranicza okna – a nie ich utrata.

Krok 5: Budowa warstwy raportowej – domknięcie obietnicy ze wstępu

Mamy już komplet wymiarów i tabelę faktów, ale analityk wciąż musiałby samodzielnie je posklejać. Zbudujmy więc na szczycie gwiazdy jeden model raportowy, który odpowiada na pytanie ze wstępu: „sprzedaż produktów w podziale na kategorie i regiony z ostatnich 6 miesięcy”. W tym uproszczonym przykładzie regionem jest kraj użytkownika (dim_users.country). Jeśli w Twojej firmie „region” oznacza coś innego niż kraj, dodaj osobną kolumnę lub mapowanie kraju na region. To właśnie model raportowy – a nie fct_orders – jako pierwszy ref-uje wszystkie wymiary naraz, więc to on domyka brakujące krawędzie w DAG-u (te, które na poziomie samych faktów istniały tylko jako testy relationships).

-- models/marts/rpt_sales_by_category_country.sql
{{ config(materialized='table') }}

select
p.category,
u.country                   as country,
d.year,
d.month,
count(*)                    as orders_count,
sum(f.amount)               as total_sales
from {{ ref('fct_orders') }}         as f
inner join {{ ref('dim_products') }} as p on f.product_fk    = p.product_pk
inner join {{ ref('dim_users') }}    as u on f.user_fk       = u.user_pk
inner join {{ ref('dim_date') }}     as d on f.order_date_fk = d.date_pk
where f.status = 'completed'                          -- „sprzedaż" = tylko zrealizowane zamówienia
-- bieżący miesiąc + 5 poprzednich miesięcy kalendarzowych
and d.date_pk >= (date_trunc('month', current_date)::date - interval '5 months')::date
group by p.category, u.country, d.year, d.month
order by d.year, d.month, total_sales desc

A oto efekt – to, co realnie ląduje na biurku marketingu: jedna płaska tabela zamiast 200 linii SQL-a za każdym razem.

category country year month orders_count total_sales
Electronics PL 2026 1 312 148230.00
Home DE 2026 1 201 87410.50
Electronics PL 2026 2 298 141870.00
… … … … … …

Trzy rzeczy warto tu dostosować do siebie. Po pierwsze, definicja „sprzedaży”: status = 'completed' żyje w jednym miejscu, więc jeśli liczysz przychód inaczej (np. osobno modelujesz zwroty), zmieniasz to tylko tutaj – a wartości statusu w stylu completed/refunded to założenie, które dopasujesz do swojego słownika statusów. Po drugie, ziarnistość: jeśli zamiast rozbicia miesiąc-do-miesiąca wolisz jedną sumę za cały okres, usuń d.year, d.month z select i group by. Po trzecie, filtr daty oznacza bieżący miesiąc plus 5 poprzednich miesięcy kalendarzowych. Jeśli potrzebujesz 6 pełnych zakończonych miesięcy, dodaj też górną granicę: d.date_pk < date_trunc('month', current_date)::date i ustaw dolną granicę na date_trunc('month', current_date)::date - interval '6 months'.

Jedna pułapka warta uwagi: count(*) liczy tu zamówienia, nie sztuki sprzedanych produktów. To poprawne tylko dla naszego uproszczonego modelu, w którym jedno zamówienie dotyczy jednego produktu albo interesuje nas liczba zamówień. Gdyby któryś wymiar miał duplikaty, liczby zostałyby zawyżone (przed czym chronią testy unique z kroku 6). Z kolei inner join w parze z testami not_null i relationships sprawia, że zamówienia z obowiązkowymi, poprawnymi FK nie znikną po cichu z raportu.

Tabela czy widok? We wstępie obiecaliśmy „gotową tabelę”, więc świadomie dajemy materialized='table' – raport liczy się raz, na nocnym harmonogramie, a BI czyta gotowy wynik. Jeśli wynik jest mały i potrzebujesz świeżości na bieżąco, możesz zmienić na materialized='view' (zawsze aktualny, ale liczony przy każdym zapytaniu). A gdy raport urośnie i pełne przeliczanie zacznie boleć – wracasz do incremental, dokładnie jak przy fct_orders w kroku 4.

Krok 6: Pakiety i testy jakości danych

W dbt testy to nie luksus, to standard. Najpierw dodajemy dbt_utils – pakiet, z którego korzystaliśmy już w dim_date i z którego skorzystamy teraz w testach.

# packages.yml
packages:
  - package: dbt-labs/dbt_utils
    version: [">=1.1.0", "<2.0.0"]

Następnie models/marts/schema.yml:

version: 2
models:
  - name: dim_users
    columns:
      - name: user_pk
        data_tests:
          - unique
          - not_null
      - name: country
        data_tests:
          - not_null

* name: dim_products
  columns:

  * name: product_pk
    data_tests:

    * unique
    * not_null
  * name: category
    data_tests:

    * not_null

* name: dim_date
  columns:

  * name: date_pk
    data_tests:

    * unique
    * not_null

* name: fct_orders
  columns:

  * name: order_pk
    data_tests:

    * unique
    * not_null
  * name: user_fk
    data_tests:

    * not_null
    * relationships:
      arguments:
      to: ref('dim_users')
      field: user_pk
  * name: product_fk
    data_tests:

    * not_null
    * relationships:
      arguments:
      to: ref('dim_products')
      field: product_pk
  * name: order_date_fk
    data_tests:

    * not_null
    * relationships:
      arguments:
      to: ref('dim_date')
      field: date_pk
  * name: status
    data_tests:

    * not_null
  * name: updated_at
    data_tests:

    * not_null
  * name: amount
    data_tests:

    * not_null
    * dbt_utils.expression_is_true:
      arguments:
      expression: ">= 0"
      config:
      severity: warn

Powyżej używamy nowszego zapisu data_tests i arguments, spotykanego w aktualnych wersjach dbt 1.x. Jeśli pracujesz na starszym projekcie dbt, możesz spotkać równoważny zapis tests oraz argumenty testu bez dodatkowego poziomu arguments – ważna jest sama intencja: not_null, unique, relationships i warunek biznesowy na amount.

Kilka słów o tym, co tu się dzieje:

  • unique i not_null na kluczach głównych wszystkich tabel (order_pk, a także user_pk, product_pk, date_pk w wymiarach) pilnują, żeby klucze były rzeczywiście unikalne. W wymiarach chronią też przed duplikatami, które po joinie rozdmuchują (fan-out) liczby w raportach BI.
  • not_null na user_fk, product_fk i order_date_fk jest równie ważny jak relationships. Test relacji sprawdza, czy niepusta wartość FK istnieje po stronie wymiaru; nie zastępuje testu obowiązkowości FK.
  • relationships na user_fk, product_fk i order_date_fk to testy integralności referencyjnej: jeśli do fct_orders trafi zamówienie z product_id, które nie istnieje w dim_products (np. produkt został skasowany z systemu źródłowego), albo data zamówienia wypadnie poza zasięg dim_date, test zwróci błąd, a nie ciche „osierocone” wiersze w raportach.
  • not_null na updated_at pilnuje założenia, bez którego incremental po zmianach statusu przestaje być wiarygodny.
  • dbt_utils.expression_is_true z wyrażeniem >= 0 sprawdza, czy kwota zamówienia nie jest ujemna. To świadomie zdefiniowany warunek biznesowy dla tego uproszczonego modelu, w przeciwieństwie do testu accepted_values, który sprawdza przynależność do skończonego zbioru wartości i nie nadaje się do walidacji pól liczbowych o ciągłym zakresie, takich jak kwoty.

Krok 7: Instalacja zależności, uruchomienie i weryfikacja

dbt deps   # instaluje dbt_utils z packages.yml
dbt run    # buduje modele w kolejności wynikającej z zależności ref()
dbt test   # uruchamia testy z schema.yml

Oczekiwany output dbt run (skrócony) powinien pokazać modele budowane w kolejności zgodnej z zależnościami. Po stagingu dbt może budować wymiary i fct_orders równolegle, bo fct_orders nie joinuje wymiarów – odwołuje się tylko do stg_orders. Raport powstaje na końcu, ponieważ ref-uje zarówno fakt, jak i wymiary:

1 of 8 OK created sql view model dev_analytics.stg_users ................. [CREATE VIEW]
2 of 8 OK created sql view model dev_analytics.stg_products .............. [CREATE VIEW]
3 of 8 OK created sql view model dev_analytics.stg_orders ................ [CREATE VIEW]
4 of 8 OK created sql table model dev_analytics.dim_users ................ [SELECT 1234]
5 of 8 OK created sql table model dev_analytics.dim_products ............. [SELECT 87]
6 of 8 OK created sql table model dev_analytics.dim_date ................. [SELECT <liczba_dni_zależna_od_dat>]
7 of 8 OK created sql table model dev_analytics.fct_orders ............... [INSERT 5021]
8 of 8 OK created sql table model dev_analytics.rpt_sales_by_category_country [SELECT 142]

Jeśli dbt test zwróci błąd relationships na product_fk, oznacza to, że w orders znalazły się zamówienia powiązane z produktami, które nie istnieją w dim_products – warto to zbadać, zamiast ignorować, bo zwykle wskazuje na problem z synchronizacją danych źródłowych. Analogicznie błąd relationships na order_date_fk najczęściej oznacza, że jakaś data zamówienia wypadła poza zakres dim_date – wróć wtedy do start_date/end_date z kroku 3.

Dobre praktyki i pułapki

  • Zasada DRY (Don’t Repeat Yourself): jeśli używasz tego samego wyliczenia (np. ceny netto) w trzech miejscach, przenieś je do dbt Macro.
  • Staging Area: w projektach produkcyjnych zwykle unikaj łączenia wymiarów i faktów bezpośrednio z source. Najpierw stwórz modele w folderze staging/, które czyszczą nazwy kolumn, rzutują typy i dają stabilny punkt wejścia – tak jak w kroku 2.
  • Pułapka SELECT *: w dbt unikaj SELECT *. Zawsze wymieniaj kolumny jawnie – łatwiej kontrolujesz kontrakt modelu, lineage i wpływ zmian w source.
  • Materializacja: dla dużych tabel w Postgresie często warto używać materialized='incremental' razem z unique_key i sensownym filtrem zmian. Pełne przebudowy dużej tabeli faktów przy każdym uruchomieniu mogą mocno obciążyć bazę, a incremental bez poprawnego unique_key i filtra zmian zwiększa ryzyko duplikatów albo nieaktualnych danych.
  • Testy integralności: testy relationships na kluczach obcych (user_fk, product_fk, order_date_fk) w połączeniu z not_null to najprostszy sposób na wyłapanie „osieroconych” rekordów i pustych FK, zanim trafią do dashboardu w BI.

Podsumowanie

dbt w połączeniu z Postgresem to bardzo solidny punkt startowy dla zespołów, które jeszcze nie mają dedykowanej hurtowni danych – zwłaszcza przy wolumenach analitycznych liczonych w gigabajtach, a nie terabajtach. Dzięki Star Schema (z kompletem wymiarów – łącznie z dim_date i dim_products), modelowi raportowemu spinającemu fakty i wymiary w jedną gotową tabelę oraz odseparowanemu schematowi analitycznemu raporty w BI (Metabase, Looker, Tableau) mogą działać szybciej, a zmiany w strukturze bazy produkcyjnej stają się mniej stresujące. Wracając do pytania ze wstępu: „sprzedaż w podziale na kategorie i regiony z ostatnich 6 miesięcy” to teraz nie 200 linii SQL-a, tylko select * from rpt_sales_by_category_country. Gdy dane przerosną możliwości dobrze zindeksowanego Postgresa, sama struktura logiczna projektu dbt – staging, wymiary, fakty, testy – zwykle migruje do hurtowni kolumnowej bez rewolucji w modelu biznesowym. Dopasowania wymagają jednak konstrukcje specyficzne dla dialektu Postgresa: funkcje dat (to_char, extract), składnia interwałów, rzutowania ::date, indeksy, partycjonowanie czy domyślna strategia incremental (w Postgresie delete+insert, podczas gdy w innych hurtowniach często wykorzystuje się merge).

Zobacz również