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?
- Dlaczego Postgres? Baza, którą już masz
- Dlaczego dbt? SQL z procesem inżynierskim
- Zanim zaczniemy: konfiguracja, izolacja i harmonogram
- Implementacja: krok po kroku
- Dobre praktyki i pułapki
- Podsumowanie
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).
