MongoDB huunda mahusiano (one-to-one, one-to-many, many-to-many) kupitia kupachika (embedding) au kurejelea (referencing) — uchaguzi unategemea cardinality ya uhusiano, jinsi data inavyofikiwa, na kama inashirikiwa. Tofauti na njia sare ya foreign-key ya SQL, MongoDB hutoa unyumbufu kwa kila uhusiano.
{ : (), : , : { : , : } }
// ONE-TO-FEW → embed (bounded, accessed together)
{ _id: ObjectId("..."), name: "Ann", addresses: [ {...}, {...} ] } // a few addresses
// ONE-TO-MANY → reference (the "many" side references the "one")
// authors collection: { _id: "a1", name: "Ann" }
// books collection: { _id: "b1", authorId: "a1", title: "..." } // each book references its author
// ONE-TO-SQUILLIONS (huge/unbounded) → ALWAYS reference (never embed unbounded data)
// e.g. a user with millions of log entries → separate collection, reference by userId
Undani muhimu: one-to-few (pachika), one-to-many (rejelea kutoka upande wa many), one-to-squillions (rejelea kila wakati — kamwe usipachike data isiyo na mipaka, kutokana na kikomo cha nyaraka cha 16MB na utendaji).
// reference with an array of ids (on one or both sides)
{ _id: "s1", name: "Student", courseIds: ["c1", "c2"] } // student → courses
{ _id: "c1", name: "Course", studentIds: ["s1", "s2"] } // course → students (optional)
// → query and $lookup to resolve; or a separate "enrollments" collection (junction-like)
Many-to-many hutumia arrays za ids zilizorejelewa (kwa upande mmoja au pande zote mbili), au collection tofauti inayofanana na junction kwa data tajiri ya uhusiano.
// join referenced data when needed
db.books.aggregate([
{ $lookup: { from: "authors", localField: "authorId", foreignField: "_id", as: "author" } }
]);
Kuunda mahusiano ni jambo la msingi katika ubunifu wa database, na njia nyumbufu ya MongoDB inayoendeshwa na mfumo wa ufikiaji ni tofauti na foreign keys sare za SQL, hivyo kuelewa jinsi ya kuunda mahusiano katika MongoDB ni muhimu kwa kubuni miundo ya schema yenye ufanisi.
Ufahamu muhimu ni kwamba MongoDB huunda mahusiano kupitia kupachika au kurejelea kulingana na sifa za uhusiano — na kuelewa jinsi cardinality inavyoathiri uchaguzi ni ujuzi muhimu: one-to-one (kawaida pachika — hufikiwa pamoja), one-to-many ikiwa na undani wake muhimu (one-to-few → pachika kwa data iliyo na mipaka inayofikiwa pamoja; one-to-many → rejelea kutoka upande wa many; one-to-squillions → rejelea kila wakati, kamwe usipachike data isiyo na mipaka kutokana na kikomo cha nyaraka cha 16MB na utendaji), na many-to-many (arrays za ids zilizorejelewa, au collection inayofanana na junction).
Kufanya maamuzi haya yanayoendeshwa na cardinality (hasa kutambua wakati data ni kubwa mno/isiyo na mipaka kupachikwa) ni muhimu kwa kuepuka makosa ya kawaida kama kupachika arrays zisizo na mipaka (kuvimbisha nyaraka, kufikia vikomo) au kurejelea kupita kiasi data ambayo inapaswa kupachikwa.
Kuelewa jinsi ya kutatua rejeleo kwa $lookup wakati joins zinapohitajika kunakamilisha picha.
Kwa kuwa mahusiano kati ya entities ni ya asili katika miundo mingi ya data, na kwa kuwa njia nyumbufu ya MongoDB kwa kila uhusiano (pachika dhidi ya rejelea kulingana na cardinality na mifumo ya ufikiaji) ni tofauti kabisa na yenye undani zaidi kuliko foreign keys sare za SQL, kuelewa jinsi ya kuunda mahusiano katika MongoDB — maamuzi ya pachika/rejelea kulingana na cardinality (hasa tofauti ya one-to-few/many/squillions) na kutatua rejeleo — ni maarifa muhimu yanayotumika mara kwa mara kwa ubunifu wa schema wenye ufanisi wa MongoDB, yakijengwa juu ya misingi ya pachika/rejelea kushughulikia mahusiano ambayo kila programu halisi inayo, na eneo muhimu linalotofautisha uundaji madhubuti wa MongoDB na uhamishaji wa kawaida wa relational.