Accueil›Blog›Test technique bases de données graphe : Neo4j, Cypher, cas d usage data

Guide recrutement data

Test technique bases de données graphe : Neo4j, Cypher, cas d usage data

Les bases de données graphe résolvent des problèmes que le SQL traite difficilement : recommandations, détection de fraude, graphes de connaissances. En entretien spécialisé, on évalue la capacité à modéliser et requêter.

Data Builder·Juin 2025·6 min de lecture·Data Engineer · Data Scientist

Sommaire

Graphes vs SQL
Modélisation en graphe
Cypher : requêtes fondamentales
Patterns de traversée
Cas d usage data
Intégration avec Python
Grille

1Quand un graphe bat le SQL

Question discriminante

Dans quels cas une base de données graphe est-elle supérieure à une base relationnelle ?

Requêtes de traversée — 'tous les amis des amis de cet utilisateur à 3 degrés'. En SQL : 3 auto-jointures coûteuses. En graphe : traversée naturelle
Recommandations — 'utilisateurs similaires qui ont acheté des produits que vous n avez pas'. Pattern de filtrage collaboratif naturel en graphe
Détection de fraude — détecter des anneaux de fraude (même adresse IP, même IBAN entre plusieurs comptes)
Knowledge graphs — relier des entités hétérogènes (personnes, organisations, lieux, événements)
Quand SQL reste meilleur — agrégations, reporting, jointures simples sur des clés étrangères

2Modélisation en graphe : nœuds et relations

Question discriminante

Comment modélisez-vous un réseau e-commerce en graphe ?

// Nœuds (Nodes) : entités
(:User {user_id: 'U1', name: 'Alice', segment: 'premium'})
(:Product {product_id: 'P1', name: 'Chaussures', category: 'Mode'})
(:Category {name: 'Mode'})
(:Order {order_id: 'O1', date: '2025-01-15', amount: 89.90})

// Relations (Edges) : interactions
(:User)-[:PLACED]->(:Order)
(:Order)-[:CONTAINS {quantity: 2}]->(:Product)
(:Product)-[:BELONGS_TO]->(:Category)
(:User)-[:VIEWED {count: 5}]->(:Product)
(:User)-[:PURCHASED]->(:Product)  // relation directe pour les reco

// Règle de base : les relations sont aussi importantes que les nœuds
// Stocker les propriétés sur les relations (count, date, score)

3Cypher : les requêtes fondamentales

Question discriminante

Écrivez la requête Cypher pour trouver les 5 produits les plus souvent achetés ensemble.

// Produits souvent achetés ensemble (market basket analysis)
MATCH (p1:Product)<-[:CONTAINS]-(o:Order)-[:CONTAINS]->(p2:Product)
WHERE p1.product_id < p2.product_id  // éviter les doublons
RETURN
    p1.name AS product_1,
    p2.name AS product_2,
    COUNT(o) AS co_purchases
ORDER BY co_purchases DESC
LIMIT 10;

// Recommandation : produits achetés par des utilisateurs similaires
MATCH (user:User {user_id: 'U1'})-[:PURCHASED]->(p:Product)
      <-[:PURCHASED]-(similar:User)
      -[:PURCHASED]->(reco:Product)
WHERE NOT (user)-[:PURCHASED]->(reco)
RETURN reco.name, COUNT(similar) AS score
ORDER BY score DESC
LIMIT 5;

4Patterns de traversée avancés

Question discriminante

Comment détectez-vous un anneau de fraude à longueur variable avec Cypher ?

// Détection de fraude : comptes liés par même adresse IP
// à longueur variable (1 à 5 sauts)
MATCH path = (compte1:Compte)-[:UTILISE*1..5]->(:IP)<-[:UTILISE*1..5]-(compte2:Compte)
WHERE compte1.id <> compte2.id
  AND compte1.statut = 'suspect'
RETURN
    compte1.id,
    compte2.id,
    LENGTH(path) AS distance,
    [node IN NODES(path) | LABELS(node)[0] + ': ' + node.id] AS chemin
ORDER BY distance;

// Trouver le plus court chemin entre deux nœuds
MATCH path = shortestPath(
    (depart:User {id: 'U1'})-[*..10]-(arrivee:User {id: 'U99'})
)
RETURN path, LENGTH(path) AS longueur;

5Cas d usage data concrets

Question discriminante

Pour quels problèmes métier avez-vous utilisé ou envisagé Neo4j ?

Moteur de recommandation — filtrage collaboratif natif. Algorithme PageRank pour scorer les recommandations
Détection de fraude — identifier des réseaux de comptes frauduleux liés par des attributs communs
Analyse d impact — 'si ce service tombe, quels services dépendent de lui ?' (graphe de dépendances)
Knowledge graph — relier les entités métier (produits, fournisseurs, certifications) pour le search et la BI
Graphe de lineage — représenter le lineage des données comme un graphe

6Intégration Python + Neo4j

Question discriminante

Comment intégrez-vous Neo4j dans un pipeline Python ?

from neo4j import GraphDatabase
import pandas as pd

driver = GraphDatabase.driver('bolt://localhost:7687',
                              auth=('neo4j', 'password'))

def get_recommendations(user_id: str, limit: int = 10) -> list:
    with driver.session() as session:
        result = session.run("""
            MATCH (u:User {id: $user_id})-[:PURCHASED]->(p:Product)
                  <-[:PURCHASED]-(similar:User)
                  -[:PURCHASED]->(reco:Product)
            WHERE NOT (u)-[:PURCHASED]->(reco)
            RETURN reco.id AS product_id,
                   reco.name AS name,
                   COUNT(similar) AS score
            ORDER BY score DESC
            LIMIT $limit
        """, user_id=user_id, limit=limit)
        return [dict(record) for record in result]

# Export vers pandas pour analyse
with driver.session() as session:
    df = pd.DataFrame(session.run('MATCH (n:Product) RETURN n').data())

7Grille par niveau

Niveau	Maitrise	Signal GO	NO-GO
Confirmé	Modélisation basique, Cypher MATCH/RETURN, cas d usage	Modélise un problème en graphe, écrit des requêtes Cypher simples	Ne sait pas quand utiliser un graphe vs SQL
Senior	Traversées à longueur variable, algorithmes graphe, intégration Python	Détecte des patterns de fraude avec Cypher, intègre Neo4j dans un pipeline	Ne connaît pas les algorithmes de graphe (PageRank, shortest path)

Vous recrutez un Data Engineer spécialisé graphes ?

Premier entretien gratuit. Rapport GO/NO-GO sous 48h.

Tester gratuitement Reserver un appel