SQL to MongoDB Converter

How to use it

1. Paste a SELECT statement — WHERE, GROUP BY, HAVING, ORDER BY, LIMIT and OFFSET are all understood, and translation re-runs on every keystroke.
2. Read the mongosh output on the right: the badge under the header says whether you got a find() query or an aggregation pipeline.
3. Check the clause table below the panes — each SQL clause sits beside the operator it became, with a link into the MongoDB manual for that operator.
4. Copy the query, download it as a .js file for a mongosh session, or share a link that carries the SQL and the pipeline toggle.

Type a SQL SELECT on the left and read the equivalent mongosh query on the right — a find() call when one suffices, an aggregation pipeline when GROUP BY, HAVING or DISTINCT demands one. A clause-by-clause table links every translated part to the MongoDB manual, and anything outside the declared subset is refused by name instead of guessed at. Translation happens on your device; the SQL is never uploaded.

How it works

The translator reuses this site's SQL span scanner, so quoted regions are settled before any grammar work begins: a WHERE value containing the word SELECT can never derail the parse, because string literals are opaque tokens by the time clauses are recognized. Each clause then maps to its documented MongoDB counterpart — WHERE into a filter or $match, GROUP BY into $group with the key under _id, HAVING into a second $match that runs after grouping, ORDER BY into sort, LIMIT and OFFSET into limit and skip. The clause table prints exactly this mapping for the query you typed, one row per clause.

LIKE becomes a $regex under a strict escape law. Wildcards translate (% to .*, _ to .), the pattern is anchored with ^ and $, and the fourteen regex metacharacters are backslash-escaped so a dot in your pattern matches a literal dot, never any character. One optimization is applied: a pattern shaped like %text% with no inner wildcard emits an unanchored /text/, the contains form the MongoDB mapping chart itself uses. Whenever an escape fired, a note names the characters it protected.

The find-versus-aggregate decision is mechanical: projection, filtering, sorting and paging all fit a single find() call, so plain SELECTs emit one. Grouping, aggregate functions and DISTINCT have no find() spelling — those queries emit a pipeline in the fixed stage order $match, $group, $match for HAVING, $sort, $skip, $limit. A toggle forces the pipeline form for plain SELECTs too, useful when the query will grow $lookup or $facet stages by hand later; the forced form projects last so sorting still sees every field.

Examples

SELECT name, seats FROM rooms WHERE building IN ('A', 'B') AND seats >= 8 ORDER BY seats DESC

db.rooms.find({ building: { $in: ["A", "B"] }, seats: { $gte: 8 } }, { name: 1, seats: 1, _id: 0 }).sort({ seats: -1 })

SELECT * FROM users WHERE email LIKE '%@example.com'

db.users.find({ email: /^.*@example\.com$/ })

SELECT customer_id, SUM(price) AS total FROM orders GROUP BY customer_id HAVING SUM(price) > 250 ORDER BY total DESC

db.orders.aggregate([
  { $group: { _id: "$customer_id", total: { $sum: "$price" } } },
  { $match: { total: { $gt: 250 } } },
  { $sort: { total: -1 } }
])

SELECT title, published_at FROM posts WHERE status = 'published' ORDER BY published_at DESC, title ASC LIMIT 10 OFFSET 20

db.posts.find({ status: "published" }, { title: 1, published_at: 1, _id: 0 }).sort({ published_at: -1, title: 1 }).skip(20).limit(10)

SELECT COUNT(DISTINCT customer_id) FROM orders WHERE total > 100

db.orders.aggregate([
  { $match: { total: { $gt: 100 } } },
  { $group: { _id: "$customer_id" } },
  { $group: { _id: null, count: { $sum: 1 } } }
])

Every example on this page is executed against the same engine that powers the tool, on every build.

Common errors

Only SELECT statements are translated — this one starts with UPDATE (INSERT, UPDATE, DELETE and DDL are out of scope).

Write statements have no query-shaped counterpart this page could honestly emit — updateOne and deleteMany carry their own operator families. Paste the SELECT part of your workload instead.

JOIN is not translated — a half-right join pipeline is worse than a refusal. The JOIN edge note on this page covers the manual route.

A typed refusal with the offending keyword's line and column. Strip the JOIN and translate the single-collection core, then add a hand-written $lookup stage where the pipeline needs it.

Subqueries are not translated — the inner SELECT has no direct MongoDB equivalent here.

IN (SELECT …), scalar subqueries and CTEs all stop the run at the inner SELECT's position. Run the inner query first and inline its result as a literal list, which the IN operator translates happily.

Use IS NULL / IS NOT NULL — a comparison with NULL is never true in SQL's three-valued logic.

= NULL is a classic SQL slip this tool refuses to launder into { field: null } silently, because the two behave differently. Rewrite with IS NULL and the translation proceeds — the null edge note explains what the filter then matches.

Keyboard shortcuts

⌘/Ctrl + Enter

Re-run the translation on demand.

⌘/Ctrl + S

Download the query as a .js file.

⌘/Ctrl + C

Copy the whole query when no text is selected.

⌘/Ctrl + Shift + C

Copy the whole query even mid-selection.

t

Swap between the light and dark palettes.

? or ⌘/Ctrl + /

Pull up the shortcut reference dialog.

Esc

Close the open dialog.