Write SQL.
Run MongoDB.

const results = await db.sql(`
  SELECT name, email, created_at
  FROM users
  WHERE status = 'active'
    AND age >= 21
  ORDER BY created_at DESC
  LIMIT 20
`);

[
  { $match: {
      status: "active",
      age: { $gte: 21 }
  }},
  { $project: {
      name: 1, email: 1,
      created_at: 1, _id: 0
  }},
  { $sort: { created_at: -1 }},
  { $limit: 20 }
]

const results = await db.sql(`
  SELECT u.name, o.total, o.date
  FROM users u
  INNER JOIN orders o
    ON u.id = o.user_id
  WHERE o.total > 100
  LIMIT 50
`);

[
  { $lookup: {
      from: "orders",
      localField: "id",
      foreignField: "user_id",
      as: "o"
  }},
  { $unwind: "$o" },
  { $match: {
      "o.total": { $gt: 100 }
  }},
  { $project: {
      name: 1,
      "o.total": 1,
      "o.date": 1, _id: 0
  }},
  { $limit: 50 }
]

const results = await db.sql(`
  SELECT u.name, p.amount
  FROM users u
  FULL OUTER JOIN payments p
    ON u.id = p.user_id
  LIMIT 100
`);

// Pipeline 1: LEFT JOIN (users -> payments)
[{ $lookup: { from: "payments", ... }},
 { $unwind: {
     path: "$p",
     preserveNullAndEmptyArrays: true }}]

// Pipeline 2: anti-join (payments not in users)
[{ $lookup: { from: "users", ... }},
 { $match: { "u": { $size: 0 }}}]

// Results merged with $unionWith

const results = await db.sql(`
  SELECT name, email
  FROM users
  WHERE id IN (
    SELECT user_id
    FROM orders
    WHERE total > 500
  )
  LIMIT 25
`);

// Phase 2: subquery resolved FIRST
// orders.aggregate([
//   { $match: { total: { $gt: 500 }}},
//   { $project: { user_id: 1 }}
// ]) => [42, 87, 156, ...]

// Phase 3: resolved values injected
[
  { $match: {
      id: { $in: [42, 87, 156, ...] }
  }},
  { $project: {
      name: 1, email: 1, _id: 0
  }},
  { $limit: 25 }
]

const results = await db.sql(`
  SELECT category,
         COUNT(*) AS total,
         AVG(price) AS avg_price
  FROM products
  GROUP BY category
  HAVING COUNT(*) > 10
  ORDER BY avg_price DESC
  LIMIT 20
`);

[
  { $group: {
      _id: "$category",
      total: { $sum: 1 },
      avg_price: { $avg: "$price" }
  }},
  { $match: {
      total: { $gt: 10 }
  }},
  { $project: {
      category: "$_id",
      total: 1,
      avg_price: 1, _id: 0
  }},
  { $sort: { avg_price: -1 }},
  { $limit: 20 }
]

const results = await db.sql(`
  SELECT name, department, salary,
    RANK() OVER (
      PARTITION BY department
      ORDER BY salary DESC
    ) AS rank
  FROM employees
  LIMIT 50
`);

[
  { $setWindowFields: {
      partitionBy: "$department",
      sortBy: { salary: -1 },
      output: {
        rank: {
          $rank: {}
        }
      }
  }},
  { $project: {
      name: 1, department: 1,
      salary: 1, rank: 1,
      _id: 0
  }},
  { $limit: 50 }
]

const results = await db.sql(`
  SELECT name, salary,
    CASE
      WHEN salary > 100000 THEN 'senior'
      WHEN salary > 60000  THEN 'mid'
      ELSE 'junior'
    END AS level
  FROM employees
  LIMIT 50
`);

[
  { $project: {
      name: 1,
      salary: 1,
      level: {
        $switch: {
          branches: [
            { case: { $gt: ["$salary", 100000]},
              then: "senior" },
            { case: { $gt: ["$salary", 60000]},
              then: "mid" }
          ],
          default: "junior"
        }
      },
      _id: 0
  }},
  { $limit: 50 }
]

const result = await db.sql(`
  INSERT INTO users (name, email, role)
  VALUES ('Alice', 'alice@co.io', 'admin')
  RETURNING id, name, created_at
`);

// 1. insertOne executed
db.users.insertOne({
  name: "Alice",
  email: "alice@co.io",
  role: "admin"
})

// 2. RETURNING fields fetched
// { id: "6614a...", name: "Alice",
//   created_at: "2026-03-29T..." }

const results = await db.sql(
  `SELECT * FROM users
   WHERE role = ? AND age > ?
   LIMIT 10`,
  ['admin', 25]
);

const results = await db.sql(
  `SELECT * FROM users
   WHERE role = $1 AND age > $2
   LIMIT 10`,
  ['admin', 25]
);

const plan = await db.sql(
  `SELECT name FROM users
   WHERE status = 'active'
   LIMIT 10`,
  [],
  { explain: true }
);

// Returns the MongoDB pipeline
// without executing it

{
  sql: "SELECT name FROM users...",
  collection: "users",
  operation: "aggregate",
  pipeline: [
    { $match: { status: "active" }},
    { $project: { name: 1, _id: 0 }},
    { $limit: 10 }
  ]
}