Incolla una query SQL e ottieni subito l'equivalente MongoDB. Supporta SELECT, INSERT, UPDATE, DELETE, GROUP BY, HAVING, LIKE, IN, IS NULL e altro ancora.
Questo strumento traduce le query SQL standard nella sintassi equivalente di MongoDB, database NoSQL orientato ai documenti. È pensato per chi sta migrando da un database relazionale o lavora contemporaneamente con entrambi i mondi.
Scrivi la query SQL nel pannello di sinistra e la query MongoDB corrispondente compare accanto. L'analisi è affidata a un vero parser SQL, quindi anche clausole WHERE complesse e aggregazioni di base vengono convertite correttamente, non approssimate.
Operazioni SQL supportateLa selezione delle colonne e le condizioni WHERE diventano una chiamata find() di MongoDB con filtro di query e proiezione.
ORDER BY diventa sort(), LIMIT diventa limit() e OFFSET diventa skip().
GROUP BY insieme alle funzioni di aggregazione (COUNT, SUM, AVG, MIN, MAX) viene tradotto in una aggregation pipeline di MongoDB.
Un filtro HAVING diventa un secondo stage $match nella pipeline, applicato dopo il raggruppamento.
I pattern LIKE che usano % (qualsiasi sequenza di caratteri) e _ (un singolo carattere) vengono convertiti in espressioni regolari MongoDB.
Supporto completo per IN/$in, NOT IN/$nin, IS NULL, IS NOT NULL/$ne, AND/$and e OR/$or, comprese le parentesi per raggruppare le condizioni.
Un INSERT di una sola riga diventa insertOne(), un INSERT multiriga diventa insertMany(). I nomi delle colonne diventano nomi dei campi del documento.
La clausola SET diventa l'operatore $set di MongoDB e la condizione WHERE diventa il documento di filtro.
DELETE FROM con una condizione WHERE diventa deleteMany(). Da usare con attenzione: senza WHERE vengono eliminati tutti i documenti.
| Operatore SQL | Operatore MongoDB | Note |
|---|---|---|
| = | $eq (or implicit) | Corrispondenza esatta |
| != / <> | $ne | Diverso da |
| > | $gt | Maggiore di |
| >= | $gte | Maggiore o uguale a |
| < | $lt | Minore di |
| <= | $lte | Minore o uguale a |
| IN (...) | $in | Valore presente nella lista |
| NOT IN (...) | $nin | Valore non presente nella lista |
| LIKE '%x%' | $regex: /.*x.*/ | % diventa .*, _ diventa . |
| NOT LIKE | $not: /pattern/ | Espressione regolare negata |
| IS NULL | field: null | Include anche i campi assenti |
| IS NOT NULL | $ne: null | Il campo esiste e non è null |
| AND | $and | Tutte le condizioni devono essere vere |
| OR | $or | Basta che una condizione sia vera |
| COUNT(*) | $sum: 1 | All'interno dello stage $group |
| SUM(f) | $sum: "$f" | All'interno dello stage $group |
| AVG(f) | $avg: "$f" | All'interno dello stage $group |
| MIN(f) | $min: "$f" | All'interno dello stage $group |
| MAX(f) | $max: "$f" | All'interno dello stage $group |
| ORDER BY ASC | sort({ f: 1 }) | Crescente |
| ORDER BY DESC | sort({ f: -1 }) | Decrescente |
| LIMIT n | limit(n) | |
| OFFSET n | skip(n) |
Stai passando da MySQL, PostgreSQL, SQL Server o SQLite a MongoDB? Traduci rapidamente la logica delle query esistenti e riduci il rischio di errori durante la migrazione.
Se conosci già SQL, vedere ogni concetto affiancato al suo equivalente è la strada più rapida per imparare il linguaggio di query di MongoDB e il modello a documenti che c'è dietro.
Anche chi usa MongoDB da anni spesso ragiona prima in SQL. Usa il convertitore come riferimento veloce per trasformare quel modello mentale nella sintassi corretta.
Condividi le query convertite con colleghi che provengono dal mondo relazionale. Un riferimento comune elimina gli attriti tra due culture di database diverse.
Incolla l'istruzione SQL nel pannello di input e premi Converti. Lo strumento analizza l'SQL e restituisce il comando equivalente per la shell MongoDB: SELECT diventa find(), le condizioni WHERE diventano un filtro di query, ORDER BY diventa sort() e LIMIT e OFFSET diventano limit() e skip(). Non serve registrarsi né installare nulla.
MongoDB non ha la parola chiave LIKE: la ricerca per pattern si fa con $regex. Il carattere jolly % di SQL diventa .* e il carattere _ diventa un singolo punto. Quindi WHERE name LIKE '%mongo%' si converte in { name: { $regex: /.*mongo.*/ } }, mentre NOT LIKE viene racchiuso in $not.
GROUP BY corrisponde a una aggregation pipeline con uno stage $group. Le colonne raggruppate diventano l'_id di quello stage e le funzioni di aggregazione diventano accumulatori: COUNT(*) diventa { $sum: 1 }, SUM(campo) diventa { $sum: "$campo" }, mentre AVG, MIN e MAX corrispondono a $avg, $min e $max. Una clausola HAVING diventa un secondo stage $match collocato dopo $group.
Non in automatico. Una JOIN in MongoDB richiede uno stage $lookup e una decisione su come modellare i dati collegati, se incorporati o referenziati: dipende dal disegno dello schema, non dall'SQL di partenza. Converti qui le query su una sola tabella e aggiungi tu lo stage $lookup.
No. Questo convertitore traduce la sintassi delle query, non i dati. Per spostare le righe serve uno strumento di migrazione come MongoDB Relational Migrator, che è gratuito e supporta Oracle, SQL Server, MySQL e PostgreSQL. Usa questo convertitore in parallelo per tradurre le query già presenti nel codice della tua applicazione.
Sì. Lo strumento è completamente gratuito, funziona nel browser, non richiede alcun account e non conserva le tue query. È disponibile in inglese, italiano, russo, cinese, francese e spagnolo.
Convertire le query è l'ultimo passo. Queste guide affrontano la parte che decide l'esito di una migrazione: come ridisegnare uno schema relazionale in documenti.