SQL to MongoDB

SQL and MongoDB query languages look different but express many of the same ideas. WHERE becomes $match, GROUP BY becomes $group, JOIN becomes $lookup, ORDER BY becomes $sort. Developers moving between the two regularly rediscover this mapping and spend time translating queries by hand. This converter automates the translation so you can paste SQL and get the MongoDB equivalent — either a find() call for simple reads or an aggregation pipeline for anything more complex.

The tool handles the core of SQL: SELECT with projections, WHERE with boolean operators, JOIN (inner, left, right, full), GROUP BY with HAVING and aggregate functions (COUNT, SUM, AVG, MIN, MAX), ORDER BY with multiple columns and directions, LIMIT and OFFSET, and subqueries where possible. The output is a MongoDB query or pipeline formatted for the mongo shell, which you can paste directly into MongoDB Compass or your Node.js driver code.

Beyond the translation, the tool explains each stage of the resulting pipeline. A SQL JOIN becomes a $lookup stage plus $unwind plus $match, and seeing that decomposition helps you understand why MongoDB needs more stages and how the data flows. Edge cases are flagged explicitly: correlated subqueries, full outer joins, and window functions have no direct MongoDB equivalent in older versions and may require manual restructuring or MongoDB 5.0+ features. For a developer migrating an app or a team learning aggregation pipelines, this converter is a starting point that saves hours of research and trial-and-error.

SQL is declarative: you describe what you want and the optimizer figures out how to retrieve it. MongoDB's query language is closer to a pipeline: you chain stages that transform documents from the collection toward the desired result. The translation is not always straightforward because the two models solve the same problem differently.

Key mappings:
- SELECT fields: becomes $project stage in aggregation or a projection document in find()
- WHERE: becomes $match stage or find filter
- JOIN: becomes $lookup stage, with $unwind to flatten arrays and optional $match to filter
- GROUP BY: becomes $group with _id set to the grouping key
- HAVING: becomes $match after $group
- Aggregate functions (COUNT, SUM, AVG): become $sum, $avg, $min, $max in $group accumulators
- ORDER BY: becomes $sort
- LIMIT/OFFSET: become $limit and $skip
- DISTINCT: becomes $group with _id on the distinct fields

Differences that require care:
- MongoDB has no schema-enforced joins; $lookup joins by explicit field matching
- SQL's NULL handling differs from MongoDB's handling of missing fields versus null values
- SQL's CASE WHEN becomes $cond or $switch in aggregation
- Subqueries translate to nested pipelines or multiple $lookup stages
- SQL's EXISTS becomes $match with an array size check after $lookup

For complex SQL with window functions or CTEs, MongoDB 5.0+ supports $setWindowFields and views provide CTE-like functionality. Older MongoDB versions may require application-level workarounds. The converter flags these and suggests alternatives where possible.

Manual SQL-to-MongoDB translation is error prone and slow, especially for complex JOINs and aggregations. MongoDB documentation covers aggregation pipelines well but doesn't start from SQL knowledge. ORMs like Prisma can generate MongoDB queries from schema but not from SQL source. This tool is purpose-built: paste SQL, get MongoDB. Works offline in the browser, explains each stage, and flags SQL features that don't translate cleanly. Best for migration work, learning aggregation pipelines, and teams moving from relational databases to MongoDB.