SQL for MongoDB that just works

QueryLeaf is available for Node.js, as a cli, and as a standalone webserver

SQL

MongoDB

SELECT u.name, COUNT(o._id) as order_count
FROM users u
LEFT JOIN orders o ON u._id = o.userId
WHERE u.status = 'active'
  AND o.items[0].price > 100
GROUP BY u.name
ORDER BY order_count DESC
LIMIT 5

The SQL you write → MongoDB executes

Why QueryLeaf?

Write in SQL, run on MongoDB with zero translation hassle

🔄

Seamless SQL Translation

QueryLeaf is a PostgreSQL dialect SQL layer for MongoDB that lets your team use familiar SQL without compromising on MongoDB's power.

📄

Document-Aware SQL

Easily access nested fields, arrays, and complex document structures with a SQL syntax that understands MongoDB's document model.

🧰

Multiple Ways to Use

Use as a library in your code, run the CLI for terminal access, or launch the web server for a MongoDB SQL proxy - flexible options for every workflow.

⚡

Zero Infrastructure Change

Works with your existing MongoDB client instances — no proxies, no middleware, no separate services. Minimal overhead, maximum compatibility.

SQL Queries for MongoDB Documents

Write familiar PostgreSQL syntax while QueryLeaf automatically handles nested fields, array elements, and MongoDB ObjectIDs

SQL

SELECT 
  name, 
  address.city,
  address.geo.coordinates[0] AS longitude,
  preferences.colors[1] AS secondary_color
FROM users
WHERE address.country = 'USA' 
  AND preferences.theme = 'dark'
  AND _id = '507f1f77bcf86cd799439011'

→

MongoDB

db.collection('users').find(
  { 
    'address.country': 'USA',
    'preferences.theme': 'dark',
    '_id': ObjectId('507f1f77bcf86cd799439011')
  }, 
  { 
    'name': 1, 
    'address.city': 1,
    'address.geo.coordinates.0': 1,
    'preferences.colors.1': 1
  }
)

SQL

-- JOIN with automatic ObjectID handling
SELECT u.name, o.total, o.status 
FROM users u 
JOIN orders o ON u._id = o.userId 
WHERE o.items[0].price > 100
  AND o.shipping.address.city = 'Chicago'

→

MongoDB

db.collection('users').aggregate([
  {
    $lookup: {
      from: "orders",
      localField: "_id",
      foreignField: "userId",
      as: "orders"
    }
  },
  { $unwind: { path: "$orders", preserveNullAndEmptyArrays: true } },
  {
    $match: {
      'orders.items.0.price': { $gt: 100 },
      'orders.shipping.address.city': 'Chicago'
    }
  },
  {
    $project: {
      name: 1,
      total: "$orders.total",
      status: "$orders.status"
    }
  }
])

View Full SQL Syntax Guide

Four Ways to Use QueryLeaf

Choose the right option for your workflow

1. Library Integration

Seamlessly integrate SQL to MongoDB translation into your application
Use with existing MongoDB client instances
Zero infrastructure change required
Minimal memory and CPU overhead
TypeScript support with full type definitions

Library Installation See Examples

import { QueryLeaf } from '@queryleaf/lib';
import { MongoClient } from 'mongodb';

// Your existing MongoDB client
const mongoClient = new MongoClient('mongodb://localhost:27017');
await mongoClient.connect();

// Create QueryLeaf with your MongoDB client
const queryLeaf = new QueryLeaf(mongoClient, 'mydatabase');

// Execute SQL queries against MongoDB
const results = await queryLeaf.execute(`
  SELECT u.name, u.email, COUNT(o._id) as order_count 
  FROM users u 
  LEFT JOIN orders o ON u._id = o.userId
  WHERE u.status = 'active'
  GROUP BY u.name, u.email
  ORDER BY order_count DESC
  LIMIT 10
`);

// Regular MongoDB operations still work normally
const db = mongoClient.db('mydatabase');
await db.collection('logs').insertOne({ 
  event: 'query_executed', 
  timestamp: new Date() 
});

# Install globally
npm install -g @queryleaf/cli

# Execute a query
queryleaf --db mydb --query "SELECT * FROM users WHERE age > 21"

# Interactive mode
queryleaf --db mydb --interactive

sql> SELECT name, email FROM users LIMIT 5;
name      | email                | age
----------+----------------------+-----------
John Doe  | john@example.com     | 30
Jane Smith| jane@example.com     | 25
...

sql> .tables
Collections in database:
  users
  products
  orders

2. Command-Line Interface

Query MongoDB databases using SQL from your terminal
Interactive SQL shell with auto-completion
Export results to JSON or CSV formats
Great for scripts, data extraction, and quick queries
View collection schemas and database structure

CLI Documentation

3. Web Server

Run a MongoDB SQL proxy service with built-in web UI
RESTful API for SQL query execution
Connect analytics tools that expect SQL databases
Swagger API documentation included
Secure with built-in rate limiting and CORS support

Server Documentation

# Install globally
npm install -g @queryleaf/server

# Start the server
MONGO_DB=mydb queryleaf-server

# Server starts on port 3000
# - Web UI at http://localhost:3000
# - API at http://localhost:3000/api
# - Swagger docs at http://localhost:3000/api-docs

// API usage
const response = await fetch('http://localhost:3000/api/query', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    sql: 'SELECT * FROM users WHERE age > 21'
  })
});

const { results, rowCount, executionTime } = await response.json();

4. PostgreSQL Wire Protocol Server

Connect to MongoDB using any standard PostgreSQL client
Use tools like pgAdmin, DBeaver, or Beekeeper Studio
Native integration with any application supporting PostgreSQL
No specialized drivers or adapters needed
Transaction support (BEGIN, COMMIT, ROLLBACK)

PostgreSQL Server Documentation

# Install globally
npm install -g @queryleaf/postgres-server

# Start the PostgreSQL-compatible server
queryleaf-pg-server --db mydb

# Connect with any PostgreSQL client:
psql -h localhost -p 5432 -d mydb -U any_username

# Or use in your application code:
import { MongoClient } from 'mongodb';
import { PostgresServer } from '@queryleaf/postgres-server';

// Create and start the server
const mongoClient = new MongoClient('mongodb://localhost:27017');
await mongoClient.connect();

const pgServer = new PostgresServer(mongoClient, 'mydb', {
  port: 5432,
  host: 'localhost'
});

Get Started with QueryLeaf

The best of both worlds: SQL syntax with MongoDB power

Join teams that use QueryLeaf to simplify MongoDB development without sacrificing document database capabilities

Get Started Free Request a Demo