// About this tool

Qu'est-ce que ce Convertisseur SQL vers MongoDB ?

Cet outil vous aide à traduire vos requêtes SQL (Structured Query Language) standard en syntaxe de requête équivalente utilisée par MongoDB, une base de données documentaire NoSQL populaire. Il est conçu pour les développeurs en transition ou travaillant à la fois avec des bases de données relationnelles et MongoDB.

Entrez votre requête SQL dans la zone de saisie, et la requête MongoDB correspondante sera générée ci-dessous. Grâce à un analyseur SQL avancé, cet outil peut désormais gérer des requêtes plus complexes, y compris des agrégations de base et diverses clauses WHERE.

Opérations SQL Prises en Charge (Amélioré)

Ce convertisseur s'appuie sur une bibliothèque d'analyse SQL pour prendre en charge un plus large éventail d'opérations SQL :

SELECT

find() — Basic Query

Translates column selection and WHERE conditions into a MongoDB find() call with query filter and projection.

SELECT name, age FROM users
WHERE age > 25

→ db.users.find(
  { age: { $gt: 25 } },
  { name: 1, age: 1, _id: 0 }
)

SELECT

sort(), limit(), skip()

ORDER BY becomes sort(), LIMIT becomes limit(), OFFSET becomes skip().

SELECT * FROM products
ORDER BY price DESC
LIMIT 10 OFFSET 20

→ db.products.find({})
  .sort({ price: -1 })
  .skip(20).limit(10)

AGGREGATE

GROUP BY → aggregate()

GROUP BY with aggregate functions (COUNT, SUM, AVG, MIN, MAX) is translated into a MongoDB aggregation pipeline.

SELECT country,
  COUNT(*) AS total
FROM users
GROUP BY country

→ db.users.aggregate([
  { $group: { _id: { country: "$country" },
    total: { $sum: 1 } } }
])

AGGREGATE

HAVING → $match after $group

HAVING filters are translated into a second $match stage in the aggregation pipeline, applied after grouping.

SELECT category,
  AVG(price) AS avg_p
FROM products
GROUP BY category
HAVING AVG(price) > 50

→ pipeline with $group then $match

WHERE

LIKE → $regex

SQL LIKE patterns with % (any characters) and _ (single character) are converted to MongoDB regular expressions.

WHERE name LIKE '%mongo%'
→ { name: { $regex: /.*mongo.*/ } }

WHERE code LIKE 'IT_'
→ { code: { $regex: /^IT.$/ } }

NOT LIKE → { field: { $not: /pattern/ } }

WHERE

IN, IS NULL, AND/OR

Full support for IN/$in, NOT IN/$nin, IS NULL/{$eq:null}, IS NOT NULL/{$ne:null}, AND/$and, OR/$or.

WHERE status IN ('a','b')
→ { status: { $in: ["a","b"] } }

WHERE deleted_at IS NULL
→ { deleted_at: null }

WHERE a=1 AND b=2
→ { $and: [{a:1},{b:2}] }

INSERT

insertOne() / insertMany()

Single-row INSERT becomes insertOne(). Multi-row INSERT becomes insertMany(). Column names become document field names.

INSERT INTO users (name, age)
VALUES ('Alice', 30)

→ db.users.insertOne({
  name: "Alice", age: 30
})

UPDATE

updateMany() with $set

SQL SET clauses become MongoDB $set operators. The WHERE condition becomes the filter document.

UPDATE users
SET status = 'active'
WHERE id = 42

→ db.users.updateMany(
  { id: 42 },
  { $set: { status: "active" } }
)

DELETE

deleteMany()

DELETE FROM with a WHERE condition becomes deleteMany(). Use with care — no WHERE deletes all documents.

DELETE FROM sessions
WHERE expires < '2024-01-01'

→ db.sessions.deleteMany({
  expires: { $lt: "2024-01-01" }
})

// Operator mapping

SQL → MongoDB operator reference

SQL Operator	MongoDB Operator	Notes
=	$eq (or implicit)	Exact match
!= / <>	$ne	Not equal
>	$gt	Greater than
>=	$gte	Greater than or equal
<	$lt	Less than
<=	$lte	Less than or equal
IN (...)	$in	Value in list
NOT IN (...)	$nin	Value not in list
LIKE '%x%'	$regex: /.x./	% → .*, _ → .
NOT LIKE	$not: /pattern/	Negated regex
IS NULL	field: null	Includes missing fields
IS NOT NULL	$ne: null	Field exists and is not null
AND	$and	All conditions must match
OR	$or	Any condition must match
COUNT(*)	$sum: 1	In $group stage
SUM(f)	$sum: "$f"	In $group stage
AVG(f)	$avg: "$f"	In $group stage
MIN(f)	$min: "$f"	In $group stage
MAX(f)	$max: "$f"	In $group stage
ORDER BY ASC	sort({ f: 1 })	Ascending
ORDER BY DESC	sort({ f: -1 })	Descending
LIMIT n	limit(n)
OFFSET n	skip(n)

// Why use this tool

Pourquoi Convertir SQL en MongoDB ?

Database Migration

Moving from MySQL, PostgreSQL or SQLite to MongoDB? This tool helps you translate your existing query logic quickly and accurately, reducing the risk of errors during migration.

Learning MongoDB

If you know SQL, this converter shows you exactly how each SQL concept maps to MongoDB's document model — making it the fastest way to learn MongoDB query syntax.

Daily Development

Even experienced MongoDB developers sometimes think in SQL first. Use this tool as a quick reference to translate your mental model into the correct MongoDB syntax.

Team Collaboration

Share converted queries with teammates who come from a SQL background. A common language reduces friction when working across different database ecosystems.