SQL zu NoSQL

Fügen Sie eine einzelne SQL-SELECT-Anweisung ein, und der Konverter schreibt sie in eine äquivalente MongoDB-find()-Abfrage um. Er mappt die ausgewählten Spalten auf eine Projektion, die WHERE-Klausel auf einen Filter, ORDER BY auf .sort() und LIMIT auf .limit(). Es ist ein Abfrage-Umschreiber für einfache Anweisungen, kein Migrationswerkzeug: JOIN, GROUP BY, Aggregationen und Unterabfragen werden nicht unterstützt.

So funktioniert die Umwandlung

  1. 1

    Das SELECT parsen

    Das Werkzeug liest eine einzelne Anweisung der Form `SELECT Spalten FROM Tabelle [WHERE ...] [ORDER BY ...] [LIMIT n]`.

  2. 2

    Jede Klausel mappen

    Spalten werden zu einer Projektion `{ col: 1 }`, `WHERE` zu einem Filter, `ORDER BY` zu `.sort()` und `LIMIT` zu `.limit()`.

  3. 3

    Die Operatoren übersetzen

    Vergleichsoperatoren werden auf Mongo-Operatoren gemappt: `>` zu `$gt`, `<` zu `$lt`, `>=` zu `$gte`, `<=` zu `$lte`, `!=` zu `$ne` und `=` zu einer direkten Übereinstimmung.

  4. 4

    Die Ausgabe kopieren

    Die erzeugte Zeile `db.collection.find(...)` ist bereit zum Einfügen in die mongosh-Shell oder einen Treiberaufruf.

Ein durchgerechnetes Beispiel

SQL:

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

MongoDB-Abfrage:

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

Was der Konverter mappt

SQL MongoDB find()
SELECT a, b Projektion { a: 1, b: 1 }
SELECT * alle Felder (leere Projektion)
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)

Was nicht unterstützt wird

  • JOINs. Es wird nur eine einzelne Tabelle gelesen. Das Kombinieren von Sammlungen benötigt $lookup oder ein denormalisiertes Datenmodell, was eine Schema-Entscheidung ist, keine Abfrage-Umschreibung.
  • GROUP BY und Aggregationen. COUNT, SUM, AVG und GROUP BY erfordern die Aggregations-Pipeline (db.collection.aggregate([...])), die dieses Werkzeug nicht erzeugt.
  • Unterabfragen, CTEs und Fensterfunktionen. Überdenken Sie das Modell oder teilen Sie die Arbeit in Stufen auf; sie lassen sich nicht in einem find() ausdrücken.
  • IN, LIKE und BETWEEN. Der WHERE-Parser verarbeitet nur die Vergleichsoperatoren =, >, <, >=, <=, != und <>.
  • Mischung aus AND und OR. Eine WHERE-Klausel wird als vollständig AND oder vollständig OR behandelt; kombinieren Sie beide nicht in einer Anweisung.
  • INSERT, UPDATE, DELETE, CREATE TABLE. Nur SELECT wird umgewandelt.

Zur Ausgabe

Das Ergebnis ist immer eine einzelne Zeile db.collection.find(Filter, Projektion), optional gefolgt von .sort() und .limit(). Sie zielt auf die MongoDB-Shell und die Treiber ab. Sie erzeugt keine Firestore- oder Elasticsearch-Abfragen und wählt keine Indizes aus und optimiert nicht die Leistung. Testen Sie die Abfrage mit Ihren eigenen Daten, bevor Sie sich darauf verlassen.

Häufig gestellte Fragen

Nein. Die Ausgabe ist immer eine MongoDB-find()-Abfrage für die mongosh-Shell oder einen Treiber. Es gibt keine Zielauswahl für andere Dokumentspeicher.

Nein. Das benötigt die MongoDB-Aggregations-Pipeline (aggregate([...])), die dieses Werkzeug nicht erzeugt. Es produziert nur find()-Abfragen mit Filter, Projektion, Sortierung und Limit.

Nein. Es wird nur eine einzelne FROM-Tabelle gelesen. NoSQL-Speicher bevorzugen Einbetten oder Referenzieren, daher bedeutet ein JOIN meist eine Änderung des Datenmodells, keine Abfrage-Umschreibung.

Nein. Nur SELECT-Anweisungen werden umgewandelt. Sammlungen in MongoDB sind standardmäßig schemalos, es gibt also keine Tabellendefinition zu übersetzen.

Verwandte Tools

Tool in anderen Sprachen verfügbar