Wat is BSON en welke gegevenstypes ondersteunt MongoDB?

Question

Accepted Answer

**BSON** (Binary JSON) is het binaire formaat dat MongoDB gebruikt om documenten op te slaan — het breidt JSON uit met aanvullende **gegevenstypes** (zoals datums, ObjectId, binair en juiste nummertypen) en is efficiënt om op te slaan en te doorkruisen. Het begrijpen van BSON-typen helpt je gegevens correct op te slaan.

## BSON — binaire JSON met meer typen

```text
JSON has limited types (string, number, boolean, null, object, array).
BSON adds: ObjectId, Date, Binary, Decimal128, distinct Int/Long/Double, Timestamp, etc.
→ BSON is more efficient (binary, typed, traversable) and richer than plain JSON text.
```

## Veelgebruikte BSON-gegevenstypes

```js
{
  _id: ObjectId("..."),          // ObjectId — 12-byte unique id (the default _id type)
  name: "Ann",                    // String
  age: NumberInt(30),             // Int32 (32-bit integer)
  views: NumberLong(10000000000), // Int64 (64-bit — for large numbers)
  price: NumberDecimal("9.99"),   // Decimal128 — EXACT decimal (use for money!)
  rating: 4.5,                     // Double (default for numbers)
  active: true,                    // Boolean
  createdAt: ISODate("2024-01-15"),// Date (a proper date type, not a string)
  data: BinData(0, "..."),         // Binary data
  tags: ["a", "b"],                // Array
  address: { city: "NY" },          // Embedded document (object)
  deletedAt: null                   // Null
}
```

## ObjectId — de standaard _id

```js
// ObjectId is a 12-byte id: timestamp + machine/process + counter → globally unique
// It even encodes a creation timestamp:
ObjectId("...").getTimestamp();   // get when the document was created
```

De **ObjectId** (standaard `_id`) is uniek en bevat een timestamp — dus het is ruwweg in volgorde van tijd en je krijgt gratis de aanmaaktijd.

## Belangrijke typeoverwegingen

```text
✓ Use proper DATE type (ISODate), not date strings → enables date queries/sorting
✓ Use Decimal128 (NumberDecimal) for MONEY → exact (avoid Double's rounding errors)
✓ Be aware of Int32 vs Int64 vs Double — numbers default to Double; large ints need Long
✓ ObjectId vs custom _id — you can use your own _id, but ObjectId is convenient/unique
```

## Waarom het belangrijk is

Het begrijpen van BSON en MongoDB's gegevenstypes is waardevol voor **het correct en efficiënt opslaan van gegevens**, dus het is nuttige basiskennis voor het werken met MongoDB.

Dat MongoDB **BSON** (binaire JSON, rijker en efficiënter dan platte JSON) gebruikt en de **gegevenstypes die het ondersteunt** buiten basisJSON — vooral juiste **Date**-typen, **ObjectId**, **Decimal128** en onderscheidende integer/double-typen — is belangrijk voor het nauwkeurig weergeven van gegevens.

Meerdere typeoverwegingen zijn praktisch van belang: het gebruik van een juist **Date-type** (ISODate) in plaats van datumstrings (waardoor juiste datumquery's en sortering mogelijk worden — een veelgemaakte fout is het opslaan van datums als strings), het gebruik van **Decimal128 (NumberDecimal) voor geld** (exacte decimale rekenkunde, vermijding van afrondingsfouten van Double — hetzelfde kritieke correctiesprobleem als in SQL), en bewustzijn van nummertype-onderscheidingen (nummers worden standaard op Double ingesteld; grote getallen hebben Int64/Long nodig).

Het begrijpen van **ObjectId** (de standaard `_id` — een 12-byte unieke identifier die gemakshalve een aanmaaktimestamp codeert, dus het is ruwweg in volgorde van tijd en geeft je gratis de aanmaaktijd) is nuttig voor het werken met document-identifiers.

Omdat het opslaan van gegevens met de juiste typen invloed heeft op correctheid (geldnauwkeurigheid, datuumfunctionaliteit), efficiëntie en queryability, en omdat BSON's rijkere typesysteem (vooral Date, Decimal128 en ObjectId) is hoe MongoDB gegevens nauwkeurig vertegenwoordigt, het begrijpen van BSON en MongoDB's gegevenstypes — de beschikbare typen, de geld-/datumoverwegingen en ObjectId — is waardevol, praktisch relevant kennis voor het correct ontwerpen van MongoDB-gegevens en het vermijden van veelgemaakte typefouten (zoals stringdatums of zwevend-kommagetallen voor geld), een nuttig aspect van effectief werken met de database.