MongoDB : modélisation des données

La modélisation des données dans MongoDB représente un changement de paradigme majeur pour les développeurs et data scientists habitués aux bases de données relationnelles. En tant que base de données orientée documents, MongoDB offre une flexibilité incomparable dans la structuration des données, mais nécessite une approche réfléchie pour optimiser les performances et la maintenabilité.

Les concepts fondamentaux de la modélisation MongoDB

Contrairement aux bases SQL qui utilisent des tables et des relations, MongoDB organise les données en collections de documents BSON (Binary JSON). Cette structure permet une grande flexibilité mais nécessite de bien comprendre certains concepts clés :

• Document : Unité de base stockant les données sous forme de paires clé-valeur
• Collection : Groupe de documents, équivalent conceptuel d'une table SQL
• Embedded Documents : Documents imbriqués permettant de représenter des relations
• References : Liens entre documents via leurs identifiants uniques (_id)

Stratégies de modélisation

1. Embedded Documents (Documents imbriqués)

Cette approche consiste à imbriquer les données liées directement dans le document parent :

{
   "_id": "user123",
   "name": "Jean Dupont",
   "address": {
      "street": "123 Rue de Paris",
      "city": "Paris",
      "country": "France"
   },
   "orders": [
      {
         "order_id": "ord456",
         "date": "2023-12-01",
         "items": ["item1", "item2"]
      }
   ]
}

2. References (Références)

Pour les relations complexes ou les données fréquemment mises à jour, on préfère utiliser des références :

// Collection Users
{
   "_id": "user123",
   "name": "Jean Dupont",
   "order_ids": ["ord456", "ord789"]
}

// Collection Orders
{
   "_id": "ord456",
   "user_id": "user123",
   "date": "2023-12-01",
   "items": ["item1", "item2"]
}

Implémentation en Python avec PyMongo

Voici un exemple d'implémentation utilisant PyMongo pour gérer les données :

from pymongo import MongoClient
import pandas as pd

# Connexion à MongoDB
client = MongoClient('mongodb://localhost:27017/')
db = client['ecommerce_db']
# Fonction pour insérer un nouvel utilisateur avec ses commandes
def create_user_with_orders(user_data, orders_data):
    try:
        # Création du document utilisateur
        user = {
            "name": user_data["name"],
            "email": user_data["email"],
            "orders": orders_data
        }
        
        # Insertion dans la collection users
        result = db.users.insert_one(user)
        return result.inserted_id
    except Exception as e:
        print(f"Erreur lors de l'insertion : {e}")
        return None
# Exemple d'utilisation
user_data = {
    "name": "Jean Dupont",
    "email": "jean@example.com"
}
orders_data = [
    {
        "order_id": "ord456",
        "date": "2023-12-01",
        "items": ["item1", "item2"]
    }
]
user_id = create_user_with_orders(user_data, orders_data)

Bonnes pratiques de modélisation

• Dénormalisation intelligente : Imbriquer les données fréquemment accédées ensemble
• Limites de taille : Éviter les documents dépassant 16MB
• Cardinalité des relations : Utiliser des références pour les relations many-to-many
• Cohérence des schémas : Maintenir une structure cohérente malgré la flexibilité

Patterns d'accès aux données

La modélisation doit prendre en compte les patterns d'accès typiques :

# Exemple de requête d'agrégation
pipeline = [
    {"$match": {"name": "Jean Dupont"}},
    {"$unwind": "$orders"},
    {"$group": {
        "_id": "$_id",
        "total_orders": {"$sum": 1},
        "last_order_date": {"$max": "$orders.date"}
    }}
]

result = db.users.aggregate(pipeline)

Optimisation des performances

Plusieurs stratégies permettent d'optimiser les performances :

• Création d'index appropriés
• Limitation de la taille des documents
• Pagination des résultats
• Monitoring des requêtes lentes

# Création d'index composé
db.users.create_index([
    ("name", 1),
    ("email", 1)
], unique=True)

# Requête paginée
def get_paginated_users(page_size=10, page_num=1):
    skip = (page_num - 1)  page_size
    return db.users.find().skip(skip).limit(page_size)

# Définition d'un schéma de validation
validator = {
    "$jsonSchema": {
        "bsonType": "object",
        "required": ["name", "email"],
        "properties": {
            "name": {
                "bsonType": "string",
                "description": "must be a string and is required"
            },
            "email": {
                "bsonType": "string",
                "pattern": "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
                "description": "must be a valid email address"
            }
        }
    }
}

# Application du schéma
db.command("collMod", "users", validator=validator)