Czym jest MongoDB i kiedy warto jej używać?

Mateusz Bogolubow

16-11-2026

Jak działa baza dokumentowa MongoDB: dokumenty, kolekcje, ObjectId, zapytania i agregacje, łączenie kolekcji przez $lookup. Z przykładami uruchomionymi w Pythonie i wskazówką, kiedy wybrać ją zamiast PostgreSQL.

Czym jest MongoDB i kiedy warto jej używać?
MongoDB to baza dokumentowa, czyli nierelacyjna baza, która przechowuje dane jako dokumenty podobne do JSON-a (zapisywane w formacie BSON) zebrane w kolekcje, a nie w tabelach. Dobrze sprawdza się przy danych o zmiennym kształcie, które czytasz w całości, ale przy mocno powiązanych danych relacyjna baza, np. PostgreSQL, bywa prostsza.

Początkujący mają z MongoDB podobne kłopoty: skąd się biorą identyfikatory, jak łączyć dane z różnych kolekcji i czy brak schematu to zaleta, czy pułapka. Poniżej wyjaśniamy podstawy i pokazujemy przykłady. Uruchomiliśmy je na prawdziwej bazie MongoDB 9.0.8 przez sterownik pymongo w Pythonie. Zapisu w mongosh nie testowaliśmy.

Czym jest MongoDB?

MongoDB to baza dokumentowa. Zamiast wierszy w tabelach przechowuje dokumenty, czyli zagnieżdżone struktury z polami i wartościami, podobne do JSON-a. Dokumenty trzymane są w kolekcjach (odpowiednik tabeli), a kolekcje w bazie danych. Wewnętrznie używa formatu BSON, binarnej wersji JSON-a z dodatkowymi typami, np. datą i identyfikatorem ObjectId. Pojedynczy dokument może mieć maksymalnie 16 MiB.

Ogólny przegląd rodzajów baz nierelacyjnych znajdziesz w artykule o relacyjnych i nierelacyjnych bazach danych. Tutaj skupiamy się na jednym z nich.

Jak wygląda dokument i jak się go zapisuje?

Poniższe przykłady używają kolekcji customers. Zwróć uwagę, że drugi dokument ma pola, których nie ma pierwszy (phone, tags), a pierwszy ma zagnieżdżoną listę zamówień:

from pymongo import MongoClient

client = MongoClient("mongodb://127.0.0.1:27017")
db = client["shop"]

db.customers.insert_one({
    "name": "Anna",
    "city": "Warszawa",
    "orders": [{"total": 120.5}, {"total": 35}],
})
db.customers.insert_one({
    "name": "Piotr",
    "city": "Kraków",
    "phone": "600100200",
    "tags": ["vip"],
})

W relacyjnej bazie musiałbyś najpierw zdefiniować kolumny, a zamówienia trzymać w osobnej tabeli. Tutaj wszystko o kliencie jest w jednym miejscu.

Czym jest ObjectId i dlaczego wyszukiwanie po stringu nie działa?

Każdy dokument ma pole _id. Jeśli go nie podasz, MongoDB wygeneruje ObjectId, 24-znakowy identyfikator w zapisie szesnastkowym. W naszym teście wstawiony dokument dostał takie _id. Pułapka: ObjectId to nie string, więc zapytanie o _id ze stringiem niczego nie znajdzie.

from bson import ObjectId

oid = str(customer_id)  # np. z adresu URL

db.customers.find_one({"_id": oid})            # None
db.customers.find_one({"_id": ObjectId(oid)})  # znajduje klienta

Podobnie w drugą stronę: json.dumps w Pythonie nie zserializuje ObjectId. Zamień go na str(...) przed zwróceniem z API.

Jak odpytywać dane w MongoDB?

Jak filtrować i aktualizować dokumenty?

Filtr to słownik z polami i warunkami. Można sięgać do pól zagnieżdżonych notacją z kropką, także w tablicach:

db.customers.find({"city": "Kraków"})              # Piotr
db.customers.find({"orders.total": {"$gt": 100}})  # Anna (ma zamówienie > 100)

db.customers.update_one(
    {"name": "Anna"},
    {"$set": {"city": "Gdańsk"}},
)

W naszym teście pierwszy filtr zwrócił Piotra, drugi Annę, a aktualizacja zmieniła dokładnie jeden dokument.

Jak policzyć sumę zamówień (agregacje)?

Do zestawień służy potok agregacji (aggregate), który przetwarza dokumenty etapami:

list(db.customers.aggregate([
    {"$unwind": "$orders"},
    {"$group": {"_id": "$name", "sum": {"$sum": "$orders.total"}}},
]))
# [{'_id': 'Anna', 'sum': 155.5}]

To odpowiednik GROUP BY z SQL-a. Tę samą sumę, 155.5, dostaliśmy w SQL-u z JOIN-em w artykule o relacyjnych i nierelacyjnych bazach.

Jak połączyć dane z dwóch kolekcji ($lookup)?

Gdy dane trzymasz w osobnych kolekcjach (np. orders odwołuje się do klienta przez customer_id), łączysz je etapem $lookup. To odpowiednik LEFT JOIN w SQL-u (o złączeniach piszemy w artykule o relacjach i JOIN-ach w SQL):

db.customers.aggregate([
    {"$match": {"name": "Anna"}},
    {"$lookup": {
        "from": "orders",
        "localField": "_id",
        "foreignField": "customer_id",
        "as": "orders_ref",
    }},
])

W teście Anna miała w orders_ref dwa zamówienia. Jeśli pole, po którym łączysz, ma w jednej kolekcji typ ObjectId, a w drugiej string, $lookup nic nie zwróci. To częsta pułapka, choć tego akurat nie testowaliśmy.

Czy MongoDB naprawdę nie ma schematu?

Domyślnie baza nie wymusza struktury dokumentów. W teście zapisaliśmy klienta z polem city jako liczbą 123 i baza przyjęła to bez słowa. Elastyczność ma swoją cenę: literówka w nazwie pola albo zły typ zostają w danych na zawsze.

Dlatego MongoDB pozwala dodać walidację schematu do kolekcji ($jsonSchema):

db.create_collection("users", validator={"$jsonSchema": {
    "bsonType": "object",
    "required": ["email"],
    "properties": {
        "email": {"bsonType": "string"},
        "age": {"bsonType": "int", "minimum": 0},
    },
}})

db.users.insert_one({"email": "anna@example.com", "age": 30})  # przyjęty
db.users.insert_one({"age": 5})                                # odrzucony
db.users.insert_one({"email": "x@y.pl", "age": -1})            # odrzucony

W naszym teście oba złe dokumenty zostały odrzucone z błędem Document failed validation (kod 121). Walidacja nie zmusza więc do projektowania danych z góry, ale pomaga pilnować ich jakości.

Uwaga mentora: największy błąd początkujących z MongoDB to założenie, że brak schematu oznacza brak projektowania. Zanim zaczniesz zapisywać dokumenty, zdecyduj, co zagnieżdżasz (dane czytane razem), a co trzymasz osobno i łączysz po identyfikatorze. Źle zaprojektowane dokumenty są równie bolesne jak źle zaprojektowane tabele.

Czy do MongoDB potrzebne są indeksy?

Tak, tak samo jak w bazach relacyjnych. Bez indeksu baza przegląda całą kolekcję. Indeks na polu tworzysz jednym poleceniem:

db.customers.create_index("city")

W naszym teście kolekcja miała potem dwa indeksy: domyślny na _id i nowy na city.

Kiedy wybrać MongoDB, a kiedy bazę relacyjną?

SytuacjaSensowny wybór
dokumenty o zmiennym kształcie, czytane w całości (profile, katalogi z różnymi atrybutami)MongoDB
dane silnie powiązane, dużo złączeń i raportówrelacyjna (np. PostgreSQL)
potrzebujesz twardej spójności między wieloma tabelamirelacyjna
szybki prototyp, kształt danych się zmieniaMongoDB (z walidacją schematu)
nie masz pewnościzacznij od relacyjnej

Porównanie dwóch relacyjnych baz, PostgreSQL i MySQL, znajdziesz w artykule PostgreSQL czy MySQL.

Czy MongoDB jest darmowa i na jakiej licencji?

Serwer MongoDB Community można pobrać za darmo, ale działa na licencji SSPL (Server Side Public License), a nie na klasycznej licencji open source typu MIT czy BSD. Dla zwykłej aplikacji nie ma to znaczenia, ale jeśli planujesz oferować MongoDB jako usługę innym, przeczytaj licencję. MongoDB oferuje też zarządzaną usługę w chmurze o nazwie Atlas, której nie testowaliśmy.

Uwaga mentora: jeśli nie masz konkretnego powodu, by wybrać MongoDB, zacznij od relacyjnej bazy. Jeśli jednak masz dane o zmiennym kształcie, które czytasz w całości (np. profil z różnymi polami), MongoDB wyjdzie prostsza. Włącz walidację schematu od początku, żeby do bazy nie trafiały dokumenty z literówkami w nazwach pól.

Masz pytanie do artykułu? Chcesz zgłosić błąd?

Pytaj ogólnie o temat artykułu albo napisz, co poprawić. Jeśli chcesz omówić swój konkretny przypadek, umów się na rozmowę lub . Ze względów bezpieczeństwa nie przeglądamy ani nie publikujemy żadnych linków. Wiadomości z linkami nie są zapisywane. Limit: 2 pytania na godzinę.

Wyślemy na niego link do potwierdzenia pytania i odpowiedź.

Ostateczną decyzję o opublikowaniu pytania podejmuje administrator.

Konsultacja i warsztaty devmentor.pl

Masz pytania?

Partnerzy

Firmy, z którymi współpracujemy

To partnerzy odpowiedzialni za staże po naszych kursach. Organizują je dla najlepszych absolwentów.

Zobacz wszystkich partnerów →
  • VR Medical
  • Sophona
  • Robot Force