SQL naar NoSQL

Plak een enkele SQL-SELECT-instructie en de converter herschrijft die als een gelijkwaardige MongoDB-find()-query. Hij mapt de geselecteerde kolommen naar een projectie, de WHERE-clausule naar een filter, ORDER BY naar .sort() en LIMIT naar .limit(). Het is een query-herschrijver voor eenvoudige instructies, geen migratietool: JOIN, GROUP BY, aggregaties en subquery’s worden niet ondersteund.

Hoe de conversie werkt

  1. 1

    De SELECT parsen

    De tool leest een enkele instructie in de vorm `SELECT kolommen FROM tabel [WHERE ...] [ORDER BY ...] [LIMIT n]`.

  2. 2

    Elke clausule mappen

    Kolommen worden een projectie `{ col: 1 }`, `WHERE` wordt een filter, `ORDER BY` wordt `.sort()` en `LIMIT` wordt `.limit()`.

  3. 3

    De operatoren vertalen

    Vergelijkingsoperatoren worden gemapt op Mongo-operatoren: `>` naar `$gt`, `<` naar `$lt`, `>=` naar `$gte`, `<=` naar `$lte`, `!=` naar `$ne`, en `=` naar een directe overeenkomst.

  4. 4

    De uitvoer kopiëren

    De gegenereerde `db.collection.find(...)`-regel is klaar om te plakken in de mongosh-shell of een driver-aanroep.

Een uitgewerkt voorbeeld

SQL:

SELECT name, price FROM products WHERE price > 100 ORDER BY price DESC LIMIT 5;

MongoDB-query:

db.products.find({ price: { $gt: 100 } }, { name: 1, price: 1 }).sort({ price: -1 }).limit(5)

Wat de converter mapt

SQL MongoDB find()
SELECT a, b projectie { a: 1, b: 1 }
SELECT * alle velden (lege projectie)
FROM users db.users.find(...)
WHERE a = 5 { a: 5 }
WHERE a > 5 { a: { $gt: 5 } }
WHERE a >= 5 { a: { $gte: 5 } }
WHERE a != 5 { a: { $ne: 5 } }
WHERE a AND b { a: ..., b: ... }
WHERE a OR b { $or: [ ... ] }
ORDER BY a DESC .sort({ a: -1 })
LIMIT 10 .limit(10)

Wat niet wordt ondersteund

  • JOINs. Er wordt maar één tabel gelezen. Collecties combineren vereist $lookup of een gedenormaliseerd datamodel, en dat is een schemabeslissing, geen query-herschrijving.
  • GROUP BY en aggregaties. COUNT, SUM, AVG en GROUP BY vereisen de aggregatiepijplijn (db.collection.aggregate([...])), die deze tool niet genereert.
  • Subquery’s, CTE’s en vensterfuncties. Denk het model opnieuw uit of splits het werk in fasen; ze kunnen niet in een find() worden uitgedrukt.
  • IN, LIKE en BETWEEN. De WHERE-parser verwerkt alleen de vergelijkingsoperatoren =, >, <, >=, <=, != en <>.
  • AND en OR mengen. Een WHERE-clausule wordt behandeld als volledig AND of volledig OR; combineer beide niet in dezelfde instructie.
  • INSERT, UPDATE, DELETE, CREATE TABLE. Alleen SELECT wordt omgezet.

Over de uitvoer

Het resultaat is altijd een enkele regel db.collection.find(filter, projectie), eventueel gevolgd door .sort() en .limit(). Het is bedoeld voor de MongoDB-shell en drivers. Het produceert geen Firestore- of Elasticsearch-query’s, en het kiest geen indexen en optimaliseert de prestaties niet. Test de query op je eigen data voordat je erop vertrouwt.

Veelgestelde vragen

Nee. De uitvoer is altijd een MongoDB-find()-query voor de mongosh-shell of een driver. Er is geen doelkeuze voor andere documentopslagsystemen.

Nee. Dat vereist de aggregatiepijplijn van MongoDB (aggregate([...])), die deze tool niet genereert. Het produceert alleen find()-query’s met een filter, projectie, sortering en limiet.

Nee. Er wordt maar één FROM-tabel gelezen. NoSQL-opslag geeft de voorkeur aan inbedden of refereren, dus een JOIN betekent meestal een wijziging van het datamodel, geen query-herschrijving.

Nee. Alleen SELECT-instructies worden omgezet. Collecties in MongoDB zijn standaard schemaloos, dus er is geen tabeldefinitie om te vertalen.

Gerelateerde tools

Tool beschikbaar in andere talen