SQL vers NoSQL

Collez une seule instruction SQL SELECT et le convertisseur la réécrit en une requête find() MongoDB équivalente. Il mappe les colonnes sélectionnées vers une projection, la clause WHERE vers un filtre, ORDER BY vers .sort() et LIMIT vers .limit(). C'est un réécrivain de requêtes pour instructions simples, pas un outil de migration : JOIN, GROUP BY, les agrégations et les sous-requêtes ne sont pas pris en charge.

Comment fonctionne la conversion

  1. 1

    Analyser le SELECT

    L'outil lit une seule instruction de la forme `SELECT colonnes FROM table [WHERE ...] [ORDER BY ...] [LIMIT n]`.

  2. 2

    Mapper chaque clause

    Les colonnes deviennent une projection `{ col: 1 }`, `WHERE` devient un filtre, `ORDER BY` devient `.sort()` et `LIMIT` devient `.limit()`.

  3. 3

    Traduire les opérateurs

    Les opérateurs de comparaison sont mappés vers les opérateurs Mongo : `>` vers `$gt`, `<` vers `$lt`, `>=` vers `$gte`, `<=` vers `$lte`, `!=` vers `$ne`, et `=` vers une correspondance directe.

  4. 4

    Copier la sortie

    La ligne `db.collection.find(...)` générée est prête à coller dans le shell mongosh ou un appel de driver.

Un exemple concret

SQL :

SELECT name, price FROM products WHERE price > 100 ORDER BY price DESC LIMIT 5;

Requête MongoDB :

db.products.find({ price: { $gt: 100 } }, { name: 1, price: 1 }).sort({ price: -1 }).limit(5)

Ce que mappe le convertisseur

SQL MongoDB find()
SELECT a, b projection { a: 1, b: 1 }
SELECT * tous les champs (projection vide)
FROM users db.users.find(...)
WHERE a = 5 { a: 5 }
WHERE a > 5 { a: { $gt: 5 } }
WHERE a >= 5 { a: { $gte: 5 } }
WHERE a != 5 { a: { $ne: 5 } }
WHERE a AND b { a: ..., b: ... }
WHERE a OR b { $or: [ ... ] }
ORDER BY a DESC .sort({ a: -1 })
LIMIT 10 .limit(10)

Ce qui n’est pas pris en charge

  • JOIN. Une seule table est lue. Combiner des collections nécessite $lookup ou un modèle de données dénormalisé, ce qui est une décision de schéma, pas une réécriture de requête.
  • GROUP BY et agrégations. COUNT, SUM, AVG et GROUP BY nécessitent le pipeline d’agrégation (db.collection.aggregate([...])), que cet outil ne génère pas.
  • Sous-requêtes, CTE et fonctions de fenêtre. Repensez le modèle ou découpez le travail en étapes ; ils ne peuvent pas s’exprimer dans un find().
  • IN, LIKE et BETWEEN. L’analyseur de WHERE ne gère que les opérateurs de comparaison =, >, <, >=, <=, != et <>.
  • Mélange de AND et OR. Une clause WHERE est traitée comme entièrement AND ou entièrement OR ; ne combinez pas les deux dans une même instruction.
  • INSERT, UPDATE, DELETE, CREATE TABLE. Seul SELECT est converti.

À propos de la sortie

Le résultat est toujours une seule ligne db.collection.find(filtre, projection), éventuellement suivie de .sort() et .limit(). Elle cible le shell et les drivers MongoDB. Elle ne produit pas de requêtes Firestore ou Elasticsearch, et elle ne choisit pas d’index ni n’optimise les performances. Testez la requête sur vos propres données avant de vous y fier.

Questions fréquentes

Non. La sortie est toujours une requête find() MongoDB pour le shell mongosh ou un driver. Il n’y a pas de sélecteur de cible pour d’autres magasins de documents.

Non. Cela nécessite le pipeline d’agrégation de MongoDB (aggregate([...])), que cet outil ne génère pas. Il ne produit que des requêtes find() avec filtre, projection, tri et limite.

Non. Une seule table FROM est lue. Les magasins NoSQL privilégient l’intégration ou la référence, donc une jointure implique en général un changement de modèle de données, pas une réécriture de requête.

Non. Seules les instructions SELECT sont converties. Les collections MongoDB sont sans schéma par défaut, il n’y a donc pas de définition de table à traduire.

Outils similaires

Outil disponible dans d’autres langues