Komitet architektoniczny spotyka się po raz czwarty w sprawie nowego systemu obsługi zamówień. Na tablicy dwie kolumny: argumenty za jednym frameworkiem i za drugim. Jest benchmark wydajności, porównanie liczby gwiazdek na GitHubie, analiza rynku pracy i dyskusja o tym, który ekosystem będzie żywy za pięć lat. Spotkanie trwa dwie godziny. Model danych pojawia się w protokole raz, w punkcie „do ustalenia przez zespół w pierwszym sprincie”.
Trzy lata później ten sam system dostaje wymaganie: klient biznesowy może mieć kilka oddziałów, każdy z własnym adresem dostawy i własnym limitem kredytowym. W kodzie to kilka dni pracy. W danych to tygodnie, bo „klient” od początku był jednym wierszem w jednej tabeli, z adresem, NIP-em i limitem w tych samych kolumnach, a na tej tabeli stoją faktury, raporty sprzedaży, integracja z systemem księgowym i eksport do hurtowni. Nikt już nie pamięta, który framework wybrano i dlaczego. Wszyscy wiedzą, ile kosztuje zmiana definicji klienta.
Ten artykuł jest dla architektów, szefów zespołów danych i osób, które decydują o tym, na co zespół poświęca czas na starcie projektu. Broni jednej tezy, z którą wielu doświadczonych inżynierów się nie zgodzi: w aplikacji transakcyjnej zły model danych kosztuje więcej niż zły framework, więc czas projektowy powinien iść przede wszystkim na model, a dyskusje o frameworku warto skracać. Nie chodzi o hurtownię danych ani o platformę analityczną, tylko o model systemu, który przyjmuje zamówienia, wystawia faktury i obsługuje klientów.
Dlaczego spór o framework zajmuje tygodnie, a model danych powstaje przy okazji?
Bo framework jest widoczny, a model danych nie. Framework ma nazwę, logo, społeczność, konferencje i rankingi popularności. Można go porównać w tabeli i przedstawić zarządowi. Model danych to kilkadziesiąt tabel i relacji, które na pierwszy rzut oka wyglądają oczywiście: klient, zamówienie, pozycja zamówienia, produkt. Trudno o nim dyskutować, bo każdy uczestnik spotkania ma w głowie inną wersję „oczywistego” klienta i nie wie, że inni mają inną.
Fred Brooks ujął to w „The Mythical Man-Month” w 1975 roku zdaniem, które wciąż warto powtarzać: „Pokaż mi swoje schematy blokowe i ukryj tabele, a dalej nie będę nic rozumiał. Pokaż mi tabele, a schematów blokowych zwykle nie będę potrzebował, bo będą oczywiste”. Pół wieku później schematy blokowe zastąpiły frameworki, warstwy i wzorce, ale proporcja się nie zmieniła. Struktura danych mówi o systemie więcej niż struktura kodu, bo kod jest sposobem obsłużenia danych, a nie odwrotnie.
Jest też drugi powód. Decyzja o frameworku ma właściciela i termin: architekt rekomenduje, komitet zatwierdza, sprawa zamknięta. Model danych nie ma jednego momentu decyzji. Powstaje przyrostowo, w pull requestach, często pisanych przez różne osoby pod presją terminu. Każda pojedyncza decyzja jest mała i rozsądna w swoim kontekście, a ich suma staje się najtrwalszą częścią systemu, której nikt świadomie nie zaprojektował.
Trzeci powód jest najprostszy: koszty frameworka widać od razu, a koszty modelu po latach. Zły framework spowalnia zespół w pierwszych miesiącach, więc jest o czym rozmawiać. Zły model działa poprawnie aż do pierwszego wymagania, którego nie przewidział, a wtedy decyzje zapadły dawno temu i trudno je przypisać komukolwiek.
Co właściwie rozumiemy przez model danych aplikacji transakcyjnej?
Model danych to zestaw decyzji o tym, co system pamięta i jak. Obejmuje encje (rzeczy, które system rozróżnia i śledzi: klient, umowa, zamówienie), tożsamość (po czym system wie, że to ten sam klient), relacje (zamówienie należy do klienta, pozycja do zamówienia), reguły, które muszą być zawsze spełnione (zamówienie nie może mieć ujemnej wartości, faktura musi mieć nabywcę), oraz sposób zapisywania zmian w czasie. Klasyczny podział na poziom koncepcyjny, logiczny i fizyczny jest użyteczny, ale w praktyce koszt zmian ustalają decyzje, które przecinają wszystkie trzy poziomy.
Aplikacja transakcyjna to system, który przyjmuje dane w chwili, gdy coś się dzieje w firmie: klient składa zamówienie, magazyn wydaje towar, księgowość wystawia korektę. Jej model musi pilnować poprawności w momencie zapisu, bo to on jest źródłem, z którego wszystko inne korzysta. Tym różni się od modelu hurtowni, który porządkuje dane do analizy i dostaje je już zapisane. O tym, co robi zewnętrzny konsultant przy hurtowni i jak się go rozlicza, piszemy w artykule o konsultingu hurtowni danych, a o wyborze między centralną hurtownią a rozproszonym podejściem w tekście data mesh czy data warehouse. Tutaj interesuje nas wcześniejsze ogniwo: model, którego błędy hurtownia odziedziczy, ale ich nie naprawi.
Warto też oddzielić model danych od technologii bazy. Wybór między bazą relacyjną a dokumentową to decyzja fizyczna. Pytania o tożsamość, historię i granice pojęć trzeba zadać niezależnie od tego, czy dane trafią do tabel, dokumentów czy strumienia zdarzeń. Baza dokumentowa nie zwalnia z modelowania. Przesuwa je tylko z definicji schematu do kodu aplikacji, gdzie jest mniej widoczne i trudniejsze do sprawdzenia.
Dlaczego framework da się wymienić kawałkami, a modelu danych nie?
Framework żyje wewnątrz jednej aplikacji. Jego zasięg kończy się na granicy procesu: inne systemy nie wiedzą, czy zamówienia obsługuje taki czy inny framework, bo rozmawiają z aplikacją przez interfejs albo przez dane. Dlatego framework można wymieniać modułami. Wzorzec strangler fig, który opisujemy w artykule o wymianie systemu legacy kawałek po kawałku, polega właśnie na tym, że nowa implementacja przejmuje kolejne funkcje, a stara stopniowo znika. Kłopotliwe, ale wykonalne i przewidywalne.
Model danych ma zupełnie inny zasięg. Czyta go nie tylko aplikacja, ale też raporty, zapytania analityków, integracje z księgowością i logistyką, eksporty do hurtowni, skrypty administracyjne, a coraz częściej modele uczenia maszynowego. Każdy z tych odbiorców zakodował w sobie założenia modelu: że klient ma jeden adres, że status „zakończone” oznacza zapłacone, że kwota jest w złotych. Zmiana modelu wymaga znalezienia i zmiany ich wszystkich, a część z nich jest poza kontrolą zespołu, który zmianę planuje.
Druga różnica to dane historyczne. Wymiana frameworka nie zmienia ani jednego zapisanego rekordu. Zmiana modelu wymaga przekształcenia danych zapisanych przez lata, często niespójnych, z wyjątkami, które ktoś kiedyś obszedł ręcznie. Przekształcenie trzeba zrobić bez zatrzymywania firmy, więc przez jakiś czas działają obie struktury naraz. Stripe opisał w 2017 roku, jak przenosił subskrypcje, przechowywane wcześniej jako tablica wewnątrz rekordu klienta, do osobnej tabeli. Dotyczyło to setek milionów obiektów i wymagało czterech etapów: zapisu do obu miejsc z uzupełnieniem starych danych, przeniesienia odczytów, przeniesienia zapisów i dopiero na końcu usunięcia starej struktury. To była jedna decyzja modelowa z wczesnego etapu: czy subskrypcja jest częścią klienta, czy osobną encją.
Trzecia różnica: framework się starzeje w przewidywalny sposób. Dostawca ogłasza koniec wsparcia, społeczność przenosi się gdzie indziej, zespół ma kilka lat na reakcję. Model danych starzeje się nieprzewidywalnie, bo zależy od biznesu. Nowy kanał sprzedaży, przejęcie innej firmy, zmiana przepisów albo nowy cennik mogą z dnia na dzień unieważnić założenie, które było prawdziwe od początku. Takiej daty nie da się wpisać do kalendarza.
Kiedy framework jednak kosztuje więcej niż model?
Teza ma granice i warto je nazwać, zanim ktoś wyciągnie z niej wniosek, że framework jest obojętny. Framework kosztuje więcej, gdy przestaje być wspierany, a system musi spełniać wymagania bezpieczeństwa. AngularJS jest dobrym przykładem: jego oficjalne wsparcie zakończyło się w styczniu 2022 roku, a firmy z dużymi aplikacjami w tej technologii musiały zaplanować migrację, bo luk w bezpieczeństwie nikt już nie łatał. Przy porządnie zaprojektowanym modelu danych była to jednak migracja warstwy prezentacji, a dane i reguły biznesowe zostawały na miejscu.
Framework kosztuje więcej także wtedy, gdy wciąga model danych do środka. Narzędzia do mapowania obiektowo-relacyjnego, generatory schematów z adnotacji w kodzie i frameworki z własnym, nieprzezroczystym formatem przechowywania danych sprawiają, że wymiana frameworka staje się zmianą modelu. To nie jest kontrargument wobec tezy, tylko jej potwierdzenie: drogie jest to, co dotyka danych. Dlatego dobra praktyka każe trzymać schemat jako jawny, wersjonowany artefakt, a nie efekt uboczny klas w kodzie.
Wreszcie framework kosztuje więcej, gdy zespół nie potrafi w nim pracować. Jeśli wybierzesz technologię, w której nie da się zatrudnić ludzi, każda zmiana będzie droga niezależnie od jakości modelu. Ten wymiar jest realny i opisujemy go szerzej w porównaniu React, Angular i Vue dla zastosowań enterprise. Ale zauważ, że to koszt stały i dający się oszacować z wyprzedzeniem, a nie koszt ukryty, który wychodzi przy pierwszym niespodziewanym wymaganiu.
Praktyczny wniosek: wybierz framework dojrzały, z którym zespół umie pracować, i zakończ dyskusję. Różnica między dwoma dojrzałymi frameworkami rzadko przekracza koszt jednej źle zamodelowanej encji w systemie, który działa pięć lat.
Jak decyzja o tożsamości encji ustawia koszt na lata?
Tożsamość to odpowiedź na pytanie: po czym system wie, że dwa zapisy dotyczą tej samej rzeczy. Brzmi to akademicko, dopóki nie trzeba scalić dwóch kont tego samego klienta, rozdzielić konta, które przez pomyłkę łączyło dwie firmy, albo obsłużyć klienta, który zmienił nazwę, formę prawną lub numer identyfikacyjny.
Najczęstszy błąd to używanie identyfikatora biznesowego jako klucza głównego. NIP, PESEL, numer katalogowy produktu, adres e-mail wydają się naturalnymi kluczami, bo są unikalne i znane. Problem w tym, że są unikalne w świecie biznesu, a nie w systemie. NIP może zostać wpisany z błędem i poprawiony. Spółka może się przekształcić. Klient indywidualny może zostać przedsiębiorcą, a przedsiębiorca może prowadzić kilka działalności. Adres e-mail zmienia się przy zmianie pracy. Jeśli identyfikator biznesowy jest kluczem, na którym wiszą zamówienia, faktury i historia kontaktów, każda taka zmiana staje się operacją na wszystkich powiązanych tabelach i we wszystkich systemach, które ten klucz skopiowały.
Bezpieczniejszy wzorzec to klucz techniczny bez znaczenia biznesowego, a identyfikatory biznesowe jako atrybuty z własnymi regułami unikalności i własną historią. Wtedy poprawka NIP-u jest zmianą jednego atrybutu, a nie tożsamości. To decyzja, która na starcie kosztuje kilka minut, a odwracana po latach kosztuje tygodnie.
Druga pułapka to sklejanie różnych bytów w jedną encję. „Klient” w systemie B2B to zwykle co najmniej trzy rzeczy: podmiot prawny, który płaci i dostaje fakturę, lokalizacja, do której jedzie towar, i osoba, która składa zamówienie. Gdy model ma jedną tabelę „klient”, pierwsze wymaganie typu „kilka oddziałów pod jednym płatnikiem” wymusza przebudowę. Patrick McKenzie w głośnym tekście z 2010 roku o fałszywych przekonaniach programistów na temat imion i nazwisk wyliczał założenia w rodzaju „każdy ma dokładnie jedno pełne imię i nazwisko” i „imiona i nazwiska się nie zmieniają”. Każde z tych założeń, wpisane w model, jest decyzją o tożsamości podjętą bez świadomości, że w ogóle jest decyzją.
Trzecia rzecz to duplikaty. W każdym systemie, który przyjmuje dane od ludzi, pojawią się dwa rekordy tego samego klienta. Pytanie nie brzmi, czy się pojawią, tylko co model pozwala z nimi zrobić. Czy da się scalić rekordy z zachowaniem historii obu? Czy da się wskazać, który jest nadrzędny, bez kasowania drugiego? Czy faktury wystawione na scalony rekord dalej wskazują poprawnego nabywcę? Tu model aplikacji spotyka się z zarządzaniem danymi podstawowymi. O tym, które decyzje w obszarze jakości danych i MDM warto zostawić w firmie, a które zlecić, piszemy w artykule o zarządzaniu danymi jako usłudze. Z punktu widzenia modelu wystarczy jedno: przewidzieć scalanie od początku, bo dodanie go później wymaga przejrzenia każdej relacji w systemie.
Dlaczego czas i historia to najdroższa rzecz do dodania później?
Większość systemów zaczyna od modelu, który pamięta tylko stan bieżący. Zmiana ceny nadpisuje starą cenę, zmiana adresu nadpisuje stary adres, zmiana warunków umowy nadpisuje stare warunki. To działa do pierwszego pytania o przeszłość: jaka była cena w dniu złożenia zamówienia, na jaki adres wysłaliśmy towar w marcu, jakie warunki obowiązywały, gdy klient zgłosił reklamację. Jeśli model tej informacji nie przechowuje, nie da się jej odtworzyć. Można zacząć ją zapisywać od dziś, ale przeszłość jest stracona.
Pierwszy poziom obrony to zapisywanie w transakcji tego, co obowiązywało w chwili transakcji. Pozycja zamówienia powinna zawierać cenę, stawkę podatku i rabat z chwili zamówienia, a nie odwołanie do bieżącej ceny produktu. Faktura powinna zawierać dane nabywcy z dnia wystawienia, a nie wskaźnik na bieżący rekord klienta. To proste i tanie, a mimo to bywa pomijane, bo na etapie pierwszej wersji ceny się jeszcze nie zmieniały.
Drugi poziom to daty obowiązywania. Cennik, warunki umowy, przypisanie handlowca do klienta czy limit kredytowy mają okres, w którym obowiązują. Model, który zapisuje „od kiedy do kiedy”, pozwala odpowiedzieć na pytanie o dowolny dzień i zaplanować zmianę z wyprzedzeniem. Model, który ma tylko bieżącą wartość, wymusza ręczne przełączanie o północy i nie pozwala odtworzyć stanu z przeszłości.
Trzeci poziom to historia dwuczasowa. Martin Fowler w artykule z 2021 roku opisał ją na przykładzie wynagrodzenia: podwyżka obowiązuje od 15 lutego, ale dział kadr dowiaduje się o niej później, a potem jeszcze koryguje kwotę. Trzeba więc rozróżnić dwie osie czasu: kiedy coś było prawdą w świecie (historia rzeczywista) i kiedy system się o tym dowiedział (historia zapisu). Bez drugiej osi nie da się wyjaśnić, dlaczego lutowa wypłata była taka, a nie inna, bo dane zostały od tego czasu poprawione. Dla rozliczeń, ubezpieczeń, wynagrodzeń i wszystkiego, co podlega audytowi, to nie jest akademicki niuans, tylko warunek obrony przed pytaniem kontrolera.
Bazy danych pomagają, ale nie zwalniają z decyzji. SQL Server od wersji 2016 obsługuje tabele czasowe wersjonowane systemowo, które automatycznie przenoszą poprzednie wersje wierszy do tabeli historii i pozwalają zapytać o stan „na dzień”. MariaDB ma podobny mechanizm. To jednak rozwiązuje tylko historię zapisu. Datę obowiązywania w świecie biznesu i tak trzeba zamodelować, bo baza nie wie, od kiedy klient ma nowy adres. Inną drogą jest zapisywanie zdarzeń zamiast stanów, opisane w haśle event sourcing. Daje pełną historię z natury, ale ma własne koszty: trudniejsze zapytania, wersjonowanie zdarzeń i kłopot z usuwaniem danych, do którego wrócimy przy RODO.
Dlaczego to najdroższe do dodania później? Bo historii nie da się dosztukować wstecz. Każda inna wada modelu jest naprawialna migracją. Brak historii jest naprawialny tylko od dnia naprawy.
Jak modelować pieniądze, waluty i jednostki, żeby nie przepisywać rozliczeń?
Pieniądze w modelu danych to trzy decyzje: typ liczby, waluta i zaokrąglenia. Każda z nich wygląda na szczegół implementacyjny i każda potrafi wymusić przepisanie modułu rozliczeń.
Typ liczby jest najbardziej znany, a mimo to wraca. Liczby zmiennoprzecinkowe w standardzie binarnym nie reprezentują dokładnie wartości dziesiętnych. Dokumentacja Pythona pokazuje to na prostym przykładzie: suma 0,1 + 0,1 + 0,1 porównana z 0,3 daje fałsz, bo 0,1 nie jest dokładnie jedną dziesiątą. Dla kwot oznacza to rozjazdy o grosz między sumą pozycji a wartością dokumentu, które zbierają się w raportach i uzgodnieniach. Rozwiązania są dwa: typ dziesiętny o stałej precyzji w bazie i w kodzie albo liczby całkowite w najmniejszej jednostce waluty. Stripe przyjmuje kwoty w API jako liczby całkowite w jednostkach podstawowych, na przykład 1099 oznacza 10,99 w walucie z dwoma miejscami po przecinku.
Ten sam przykład pokazuje, jak długo żyją decyzje modelowe. W dokumentacji Stripe korona islandzka i szyling ugandyjski są opisane jako waluty, które przeszły na brak części dziesiętnych, ale ze względu na zgodność wsteczną nadal trzeba je przekazywać jako wartości z dwoma miejscami po przecinku, zawsze zakończone zerami. Raz opublikowana reguła reprezentacji kwot przeżyła zmianę rzeczywistości, którą opisywała, bo zmiana modelu po stronie klientów API byłaby droższa niż utrzymanie wyjątku.
Druga decyzja to waluta. Kolumna „kwota” bez kolumny „waluta” jest założeniem, że system zawsze będzie działał w jednej walucie. W Polsce to założenie wydaje się bezpieczne, dopóki firma nie zacznie sprzedawać za granicę, kupować w euro albo rozliczać kontraktów indeksowanych kursem. Dodanie waluty do każdej kwoty w systemie, który ma ich setki, oznacza przejrzenie każdego miejsca, w którym kwoty są sumowane, porównywane lub raportowane, bo suma złotych i euro nie ma sensu. Na starcie to jedna kolumna przy każdej kwocie i jedna reguła: kwoty w różnych walutach nie są sumowane bez jawnego przeliczenia z zapisanym kursem i datą.
Trzecia decyzja to zaokrąglenia i jednostki. Czy rabat procentowy liczy się od pozycji, czy od dokumentu? Czy podatek zaokrągla się na pozycji, czy na sumie? Czy towar sprzedaje się w sztukach, kartonach i paletach, a jeśli tak, to która jednostka jest bazowa? Te reguły muszą być zapisane w modelu, a nie rozproszone po kodzie, bo inaczej każdy raport i każda integracja liczy je trochę inaczej. Polskie firmy weszły w 2026 roku w obowiązkowy Krajowy System e-Faktur: od 1 lutego dla podatników, których sprzedaż w 2024 roku przekroczyła 200 mln zł, a od 1 kwietnia dla pozostałych. Systemy, które trzymały dane faktur w porządnej, jawnej strukturze, mapowały je na ustrukturyzowany format. Systemy, w których część danych żyła w polach tekstowych i regułach rozproszonych po kodzie, musiały te dane najpierw odtworzyć.
Dlaczego statusy, flagi i pola JSON są długiem, którego nie widać w przeglądzie kodu?
Kolumna „status” to najczęstsze miejsce, w którym model danych przestaje mówić prawdę. Zaczyna od trzech wartości: nowe, w realizacji, zakończone. Po roku ma dwanaście, w tym „zakończone_częściowo”, „anulowane_po_wysyłce” i „do_wyjaśnienia”, a nikt nie potrafi powiedzieć, które przejścia między nimi są dozwolone. Raporty liczą „zakończone” na trzy sposoby, bo każdy analityk inaczej interpretuje wartości dodane później. Problem nie leży w liczbie statusów, tylko w tym, że reguły przejść żyją w kodzie, a nie w modelu. Gdy status jest jawną maszyną stanów, z tabelą dozwolonych przejść i zapisem historii przejść z datą i autorem, nowy status jest decyzją, którą widać, a nie cichym rozszerzeniem listy.
Flagi logiczne mają podobny problem w mniejszej skali. Rekord z kolumnami „czy_aktywny”, „czy_zablokowany”, „czy_usunięty” i „czy_archiwalny” ma szesnaście możliwych kombinacji, z których sensownych jest może pięć. Pozostałe jedenaście pojawi się w danych prędzej czy później, bo żadna reguła ich nie zabrania. Każdy odbiorca danych musi wtedy sam zdecydować, czy rekord aktywny i usunięty jednocześnie jest aktywny, czy usunięty. Jedna kolumna stanu z określonym zbiorem wartości jest tańsza w utrzymaniu niż cztery niezależne flagi.
Pola JSON w bazie relacyjnej to osobna kategoria. Są przydatne dla danych, których struktura naprawdę jest zmienna i których system nie interpretuje: surowej odpowiedzi zewnętrznego API, konfiguracji wtyczki, atrybutów produktu zależnych od kategorii. Stają się długiem, gdy trafiają tam dane, na których system podejmuje decyzje, tylko dlatego, że dodanie kolumny wymagało migracji. Pole JSON nie ma ograniczeń, typów ani kluczy obcych, więc baza nie pilnuje jego poprawności. Każda zmiana struktury wewnątrz JSON-a to niejawna migracja, której nikt nie przeprowadził, a stare rekordy mają starą strukturę na zawsze.
Wspólna cecha tych trzech wzorców: w przeglądzie kodu wyglądają niewinnie. Dodanie wartości do listy statusów to jedna linia. Dodanie flagi to jedna kolumna. Wrzucenie nowego pola do JSON-a to zero zmian w schemacie. Koszt pojawia się w miejscu, którego recenzent nie widzi: w raportach, integracjach i u analityka, który za rok będzie próbował zrozumieć, co oznaczają dane. Dlatego warto, by zmiany schematu przechodziły osobny przegląd, z pytaniem nie „czy kod działa”, tylko „czy model mówi prawdę o biznesie”.
Gdzie kończy się jeden model i zaczyna drugi?
Najdroższy błąd na poziomie całego systemu to próba zbudowania jednego modelu dla całej firmy. Wydaje się logiczna: jeden klient, jeden produkt, jedna prawda. W praktyce dział sprzedaży, księgowość i obsługa klienta rozumieją „klienta” inaczej. Dla sprzedaży to szansa i relacja, z historią rozmów i potencjałem. Dla księgowości to płatnik z numerem identyfikacyjnym, rachunkiem i saldem. Dla obsługi to osoba, która zgłasza problem, często bez związku z tym, kto płaci. Jedna tabela, która próbuje obsłużyć wszystkie trzy znaczenia, ma kolumny używane przez jeden dział i ignorowane przez pozostałe, a każda zmiana wymaga zgody wszystkich.
Eric Evans w książce „Domain-Driven Design” nazwał tę granicę kontekstem ograniczonym. Martin Fowler w krótkim omówieniu z 2014 roku cytuje jego stwierdzenie, że pełne ujednolicenie modelu domeny dla dużego systemu nie będzie ani wykonalne, ani opłacalne, i wskazuje „klienta” i „produkt” jako typowe słowa, które w różnych częściach organizacji znaczą co innego. Rozwiązaniem jest kilka modeli, każdy spójny w swoim obszarze, i jawne mapowanie między nimi. Model sprzedaży ma swojego klienta, model rozliczeń swojego, a łączy je identyfikator i kontrakt wymiany danych.
Granice modelu przekładają się bezpośrednio na koszt zmian. Jeśli kilka aplikacji czyta i zapisuje tę samą tabelę, każda zmiana jej struktury wymaga koordynacji wszystkich zespołów, a zespół, który chce coś zmienić, musi czekać na najwolniejszego. Jeśli każdy obszar ma własne dane, a inne obszary dostają je przez interfejs lub zdarzenia, zmiana wewnętrznej struktury jest sprawą jednego zespołu, o ile kontrakt zewnętrzny zostaje zachowany. To jest główny powód, dla którego integracja przez wspólną bazę danych jest tak droga w utrzymaniu: zamienia wewnętrzny model jednego systemu w publiczny interfejs dla wszystkich.
Szczególny przypadek granicy to podział danych między klientów w produkcie SaaS. Decyzja, czym jest najemca i czy każdy rekord ma do niego przypisanie, jest decyzją modelową z tej samej rodziny co tożsamość, a jej późniejsze dodanie dotyka każdej tabeli. Rozkładamy ją szczegółowo w artykule o decyzjach architektonicznych w budowie produktu SaaS.
Ile naprawdę kosztuje migracja schematu w działającym systemie?
Na środowisku deweloperskim zmiana schematu to sekunda. Na produkcyjnej tabeli z setkami milionów wierszy, do której cały czas zapisują użytkownicy, to operacja, która może zatrzymać system. Warto znać zachowanie swojej bazy, zanim zaplanuje się zmianę modelu.
Dokumentacja PostgreSQL mówi wprost, że jeśli nie zaznaczono inaczej, ALTER TABLE zakłada blokadę ACCESS EXCLUSIVE, czyli na czas operacji blokuje także odczyty. Część operacji jest szybka: dodanie kolumny z wartością domyślną, która nie jest funkcją zmienną, nie wymaga przepisania tabeli, bo wartość trafia do metadanych. Inne są drogie: dodanie kolumny z wartością domyślną zmienną albo zmiana typu kolumny wymaga przepisania całej tabeli i indeksów, a dokumentacja ostrzega, że może to zająć dużo czasu i tymczasowo wymagać nawet dwa razy więcej miejsca na dysku. Dodanie ograniczenia NOT NULL wymaga przeskanowania całej tabeli. Na szczęście dla kluczy obcych i ograniczeń CHECK istnieje wariant NOT VALID: ograniczenie zaczyna obowiązywać dla nowych zapisów od razu, a sprawdzenie istniejących wierszy uruchamia się osobno, z lżejszą blokadą.
W MySQL problem jest na tyle poważny, że powstały osobne narzędzia do migracji online. GitHub w 2016 roku opublikował gh-ost, uzasadniając to tym, że zmieniał schemat kilka razy dziennie, a dotychczasowe narzędzia oparte na wyzwalaczach powodowały przy jego skali przeciążenia i blokady. gh-ost czyta zmiany z dziennika binarnego bazy i kopiuje dane do tabeli-cienia, z możliwością dławienia i zatrzymania migracji w trakcie.
Narzędzia rozwiązują jednak tylko część fizyczną. Część logiczną rozwiązuje wzorzec rozszerz–migruj–zawęź. Danilo Sato opisał go w 2014 roku jako zmianę równoległą: najpierw rozszerzasz interfejs, żeby obsługiwał starą i nową wersję, potem przenosisz wszystkich odbiorców na nową, a na końcu usuwasz starą. Pramod Sadalage i Martin Fowler w artykule o ewolucyjnym projektowaniu baz danych, przepisanym w 2016 roku, dodają do tego dyscyplinę: każda zmiana bazy, łącznie z poprawkami danych, jest numerowanym skryptem migracji w repozytorium, uruchamianym automatycznie, a zmiany niszczące przechodzą przez fazę przejściową, w której baza obsługuje obie struktury, na przykład przez widok o starej nazwie.
Co z tego wynika dla kosztu? Zmiana modelu w działającym systemie nie jest jednym zadaniem, tylko serią kroków rozłożonych na tygodnie lub miesiące, z okresem, w którym utrzymujesz dwie struktury, synchronizację między nimi i porównywanie wyników. Faza migracji odbiorców bywa najdłuższa, zwłaszcza gdy odbiorcy są poza zespołem. To jest prawdziwa cena złej decyzji modelowej: nie godzina na napisanie skryptu, tylko kwartał pracy kilku osób z ryzykiem dla danych produkcyjnych. Dlatego każdy model, który będą czytać systemy spoza zespołu, warto wystawiać przez kontrakt (interfejs, widok, schemat zdarzeń z regułami zgodności), a nie przez bezpośredni dostęp do tabel. Wtedy wewnętrzna struktura może się zmieniać, a zewnętrzny kontrakt ewoluuje według jawnych reguł.
Jak RODO i retencja danych wpływają na model?
Przepisy o ochronie danych osobowych są wymaganiem modelowym, a nie tylko prawnym. Artykuł 17 RODO daje osobie, której dane dotyczą, prawo do żądania od administratora usunięcia danych, między innymi gdy nie są już niezbędne do celów, w których je zebrano, albo gdy cofnięto zgodę, a nie ma innej podstawy przetwarzania. Brzmi to jak operacja DELETE. W praktyce zderza się ze wszystkim, o czym pisaliśmy wyżej.
Historia i usuwanie są w napięciu. Model, który niczego nie nadpisuje, bo przechowuje każdą wersję rekordu albo każde zdarzenie, ma kopie danych osobowych w wielu miejscach. Tabela historii, dziennik zdarzeń, kopie w hurtowni i eksporty do systemów partnerów: wszystkie trzeba objąć usuwaniem albo anonimizacją. Jednocześnie część danych trzeba przechowywać, bo wymagają tego przepisy podatkowe czy rachunkowe, więc nie da się po prostu skasować klienta razem z jego fakturami.
Rozwiązanie leży w modelu, nie w procedurze. Dane osobowe warto oddzielić od danych transakcyjnych, tak żeby zamówienie wskazywało na osobę przez identyfikator, a imię, nazwisko, adres i telefon żyły w jednym miejscu, które da się usunąć lub zanonimizować. W modelach opartych na zdarzeniach stosuje się technikę, w której dane osobowe w zdarzeniach są szyfrowane osobnym kluczem dla każdej osoby, a usunięcie klucza czyni je nieczytelnymi bez przepisywania niezmiennego dziennika. Do tego potrzebna jest jawna polityka retencji w modelu: dla każdej kategorii danych wiadomo, jak długo jest przechowywana i co się z nią dzieje po tym czasie.
Te decyzje kosztują niewiele na starcie i bardzo dużo później. System, w którym dane osobowe są rozsiane po dziesiątkach tabel, polach tekstowych i kolumnach JSON, wymaga przy pierwszym poważnym żądaniu usunięcia danych pełnej inwentaryzacji. System, który od początku oddziela dane osobowe i zna ich retencję, obsługuje takie żądanie jedną, przetestowaną procedurą.
Jak ocenić model danych, zanim stanie się drogi?
Najtańszy moment na poprawienie modelu to tydzień przed pierwszym wdrożeniem produkcyjnym. Drugi najtańszy to teraz. Poniższa tabela zestawia decyzje, które warto przejrzeć niezależnie od tego, na jakim etapie jest system, z pytaniem kontrolnym i oceną kosztu późniejszej zmiany. Ocena kosztu jest szacunkiem jakościowym opartym na tym, ile miejsc w systemie dotyka dana decyzja, a nie zmierzoną wartością.
| Decyzja modelowa | Pytanie kontrolne | Typowy błąd | Koszt zmiany po latach | Tania decyzja na starcie |
|---|---|---|---|---|
| Tożsamość encji | Co się stanie, gdy klient zmieni NIP, nazwę lub e-mail? | Identyfikator biznesowy jako klucz główny | Wysoki: każda relacja i każdy system, który skopiował klucz | Klucz techniczny, identyfikatory biznesowe jako atrybuty z historią |
| Granice encji | Czy płatnik, miejsce dostawy i osoba zamawiająca to jedno? | Jedna tabela „klient” na wszystko | Wysoki: przebudowa relacji, raportów i integracji | Osobne encje z jawnymi relacjami |
| Scalanie duplikatów | Czy da się połączyć dwa rekordy bez utraty historii? | Brak scalania, ręczne kasowanie | Średni do wysokiego: przegląd każdej relacji | Wskazanie rekordu nadrzędnego, rekordy podrzędne zachowane |
| Historia i czas | Jaka była cena, adres, warunki w dniu X? | Nadpisywanie stanu bieżącego | Nienaprawialny wstecz | Wartości z chwili transakcji, daty obowiązywania, tabela historii |
| Pieniądze | W jakiej walucie i z jaką precyzją jest ta kwota? | Typ zmiennoprzecinkowy, brak waluty | Wysoki: każde sumowanie i raport | Typ dziesiętny lub liczby całkowite, waluta przy każdej kwocie |
| Statusy | Które przejścia są dozwolone i kto je wykonał? | Lista wartości bez reguł przejść | Średni: reinterpretacja historii | Maszyna stanów z tabelą przejść i historią |
| Pola elastyczne | Czy system podejmuje decyzje na danych z JSON-a? | Dane biznesowe w polu bez schematu | Średni: niejawne wersje struktury w starych rekordach | JSON tylko dla danych nieinterpretowanych |
| Odbiorcy zewnętrzni | Kto poza aplikacją czyta te tabele? | Bezpośredni dostęp do tabel | Wysoki: koordynacja wszystkich odbiorców | Kontrakt: interfejs, widok, schemat zdarzeń |
| Dane osobowe | Jak usunąć dane jednej osoby ze wszystkich miejsc? | Dane osobowe rozsiane po tabelach i historii | Wysoki: inwentaryzacja i przepisanie historii | Oddzielenie danych osobowych, polityka retencji |
| Migracje | Czy każda zmiana schematu jest skryptem w repozytorium? | Ręczne zmiany na produkcji | Średni: rozjazd środowisk, ryzyko przy każdej zmianie | Numerowane migracje, wzorzec rozszerz–migruj–zawęź |
Jak użyć tej tabeli? Weź trzy najważniejsze encje swojego systemu, zwykle klienta, główny dokument transakcyjny i produkt lub usługę, i przejdź przez każdy wiersz z osobą, która zna biznes, oraz z osobą, która zna bazę. Każda odpowiedź „nie wiem” albo „to zależy” to kandydat do decyzji, którą warto podjąć świadomie. Nie trzeba naprawiać wszystkiego naraz. Wystarczy wiedzieć, które decyzje są tanie teraz, a drogie za rok, i zacząć od nich.
Dla systemu, który już działa, sensownym pierwszym krokiem jest niezależny przegląd. Zespół, który zbudował model, widzi go od środka i często nie zauważa założeń, które przyjął na początku. Zewnętrzne spojrzenie na architekturę i dług techniczny pomaga ustalić, które decyzje modelowe są najdroższe i w jakiej kolejności je zmieniać. W ARDURA audyt kondycji kodu ma stały zakres, trwa 1–2 tygodnie i kosztuje od 18 000 PLN.
Jakie są kluczowe wnioski dla architekta i szefa zespołu danych?
Framework to decyzja o tym, jak zespół pisze kod. Model danych to decyzja o tym, co firma będzie wiedziała o sobie przez następne lata. Framework da się wymienić modułami, a jego koniec życia widać z wyprzedzeniem. Model danych współdzielą wszyscy odbiorcy danych, a dane zapisane w złej strukturze trzeba przekształcać bez zatrzymywania działalności. Dlatego czas projektowy powinien iść przede wszystkim na model.
Zapamiętaj sześć rzeczy. Po pierwsze, oddziel tożsamość techniczną od identyfikatorów biznesowych i przewidź scalanie duplikatów od początku. Po drugie, zapisuj w transakcjach wartości z chwili transakcji i modeluj daty obowiązywania tam, gdzie biznes zadaje pytania o przeszłość, bo historii nie da się dodać wstecz. Po trzecie, przechowuj kwoty w typie dokładnym, zawsze z walutą. Po czwarte, zamieniaj statusy i flagi w jawne maszyny stanów, a pola JSON zostaw dla danych, na których system nie podejmuje decyzji. Po piąte, wyznacz granice modeli i wystawiaj dane innym przez kontrakt, a nie przez wspólne tabele. Po szóste, planuj zmiany schematu jako serię kroków według wzorca rozszerz–migruj–zawęź i oddziel dane osobowe, zanim pojawi się pierwsze żądanie ich usunięcia.
Jeśli projektujesz nowy system albo chcesz ocenić model danych w systemie, który już działa, zobacz, jak pracujemy w tworzeniu oprogramowania na zamówienie, lub umów rozmowę. Faza discovery trwa 1–2 tygodnie i kończy się zdefiniowanym zakresem i architekturą, w tym decyzjami o modelu danych, które ustalą koszt zmian na kolejne lata.