Schritt-für-Schritt-Anleitung zur Migration von SQL-Relationsdaten zu MongoDB

Die Migration von SQL-Relationsdaten zu MongoDB ist kein einfaches Tabellenkopieren. Die Herausforderung besteht darin, zu entscheiden, welche Beziehungen als eingebettete Dokumente, welche als referenziert bleiben sollten und wie Ihre Anwendung die neue Struktur abfragen wird.

Relationale Schemata sind oft über Tabellen hinweg normalisiert. Das MongoDB-Dokumentenmodell funktioniert am besten, wenn zusammengehörige Daten, die gemeinsam gelesen werden, auch gemeinsam gespeichert werden. Diese Anleitung führt durch Planung, Transformation, Laden, Überprüfung und Anwendungsänderungen, ohne davon auszugehen, dass jede SQL-Tabelle zu einer MongoDB-Collection wird.

Verständnis der Kernunterschiede: Relationale vs. Dokumentenmodelle

Bevor Sie mit dem Migrationsprozess beginnen, ist es wichtig, die konzeptionellen Unterschiede zu verstehen:

• Relationales Modell: Daten werden in Tabellen mit vordefinierten Schemata gespeichert. Beziehungen werden über Fremdschlüssel verwaltet, was JOIN-Operationen erfordert, um zusammengehörige Daten abzurufen. Normalisierung ist ein Schlüsselprinzip.
• Dokumentenmodell (MongoDB): Daten werden in flexiblen, JSON-ähnlichen Dokumenten gespeichert. Dokumente können unterschiedliche Strukturen haben. Zusammengehörige Daten können in einem einzelnen Dokument eingebettet (Denormalisierung) oder mithilfe von anwendungsseitigen Joins oder der MongoDB-$lookup-Aggregationsstufe referenziert werden.

Dieser Unterschied in der Datenmodellierung wirkt sich direkt darauf aus, wie Sie Ihre MongoDB-Collections und -Dokumente entwerfen.

Phase 1: Planung und Schema-Design

Dies ist die kritischste Phase. Ein gut entworfenes MongoDB-Schema ist der Schlüssel zur Nutzung seiner Vorteile. Ziel ist es, Ihre Daten basierend auf den Anwendungszugriffsmustern zu modellieren, nicht nur als direkte Übersetzung Ihrer SQL-Tabellen.

1. Analysieren Sie die Zugriffsmuster Ihrer Anwendung

• Identifizieren Sie leseintensive vs. schreibintensive Operationen: Wie häufig werden Daten gelesen und wie werden sie typischerweise abgefragt? Welche Felder werden am häufigsten zusammen abgerufen?
• Bestimmen Sie häufige Abfragepfade: Was sind die häufigsten SELECT-Anweisungen in Ihrer SQL-Anwendung? Welche Tabellen werden normalerweise gejoint?
• Verstehen Sie Datenbeziehungen: Wie sind Entitäten miteinander verbunden? Handelt es sich um Eins-zu-Eins-, Eins-zu-Viele- oder Viele-zu-Viele-Beziehungen?

2. Wählen Sie Ihre Denormalisierungsstrategie

Die Stärke von MongoDB liegt in der Fähigkeit, zusammengehörige Daten einzubetten. Betrachten Sie diese Strategien:

• Einbettung (Denormalisierung): Der häufigste Ansatz. Betten Sie Dokumente oder Arrays von Dokumenten in ein übergeordnetes Dokument ein, wenn die Beziehung Eins-zu-Viele ist oder wenn Daten häufig zusammen abgerufen werden. Dies reduziert die Notwendigkeit von Joins.
  • Beispiel: Anstatt separate orders- und order_items-Tabellen zu haben, können Sie order_items als Array innerhalb des order-Dokuments einbetten.
• Referenzierung: Verwenden Sie diese, wenn die Einbettung zu übermäßig großen Dokumenten führen würde oder wenn Daten unabhängig voneinander abgerufen werden. Speichern Sie die _id eines verwandten Dokuments, ähnlich wie Fremdschlüssel, und führen Sie anwendungsseitige Joins oder die MongoDB-$lookup-Funktion durch.
  • Beispiel: Eine users-Collection und eine posts-Collection. Ein Post könnte die user_id seines Autors speichern. Sie können dann $lookup verwenden, um die Details des Autors beim Abrufen eines Posts zu erhalten.

3. Entwerfen Sie Ihre MongoDB-Collections und -Dokumente

Basierend auf Ihren Zugriffsmustern und Ihrer Denormalisierungsstrategie entwerfen Sie Ihre Collections. Ein guter Ausgangspunkt ist, SQL-Tabellen auf MongoDB-Collections abzubilden. Entscheiden Sie dann, welche zusammengehörigen Daten eingebettet und welche referenziert werden sollen.

SQL-Schema-Beispiel:

-- Customers Table
CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    Email VARCHAR(100)
);

-- Orders Table
CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    TotalAmount DECIMAL(10, 2),
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);

-- OrderItems Table
CREATE TABLE OrderItems (
    OrderItemID INT PRIMARY KEY,
    OrderID INT,
    ProductID INT,
    Quantity INT,
    Price DECIMAL(10, 2),
    FOREIGN KEY (OrderID) REFERENCES Orders(OrderID)
);

MongoDB-Dokument-Design-Optionen:

• Option A: Kunde mit eingebetteten Bestellungen, wenn Kunden eine überschaubare Anzahl von Bestellungen haben und Bestellungen häufig zusammen mit dem Kunden angezeigt werden:

  {
    "_id": ObjectId("..."),
    "customer_id": 1,
    "first_name": "John",
    "last_name": "Doe",
    "email": "[email protected]",
    "orders": [
      {
        "order_id": 101,
        "order_date": ISODate("2023-10-26T00:00:00Z"),
        "total_amount": 50.00,
        "items": [
          { "product_id": 1, "quantity": 2, "price": 25.00 },
          { "product_id": 3, "quantity": 1, "price": 0.00 }
        ]
      }
    ]
  }
  

• Option B: Separate Collections mit Referenzierung, wenn Bestellungen zahlreich sind oder oft unabhängig abgefragt werden.

  Customers-Collection:

  {
    "_id": ObjectId("..."),
    "customer_id": 1,
    "first_name": "John",
    "last_name": "Doe",
    "email": "[email protected]"
  }
  

  Orders-Collection:

  {
    "_id": ObjectId("..."),
    "order_id": 101,
    "customer_id": 1,
    "order_date": ISODate("2023-10-26T00:00:00Z"),
    "total_amount": 50.00,
    "items": [
      { "product_id": 1, "quantity": 2, "price": 25.00 },
      { "product_id": 3, "quantity": 1, "price": 0.00 }
    ]
  }
  

Überlegungen zur Dokumentgröße: MongoDB hat ein Dokumentgrößenlimit (16 MB). Vermeiden Sie das Einbetten übermäßig großer Arrays, die dieses Limit überschreiten könnten. Wenn ein Array unbegrenzt wächst, sollten Sie es in eine separate Collection auslagern.

Phase 2: Datenextraktion und -transformation

Sobald Ihr Zielschema entworfen ist, müssen Sie Daten aus Ihrer SQL-Datenbank extrahieren und in das neue Dokumentenformat transformieren.

1. Daten aus SQL extrahieren

Verwenden Sie standardmäßige SQL-Abfragen, um die benötigten Daten auszuwählen. Sie können diese Daten in Formate wie CSV oder JSON exportieren.

• Verwendung von SQL-Clients: Die meisten SQL-Datenbanktools (z. B. DBeaver, SQL Developer, pgAdmin) ermöglichen den Export von Abfrageergebnissen in CSV oder JSON.
• Skripterstellung: Schreiben Sie Skripte (Python, Node.js usw.), um eine Verbindung zu Ihrer SQL-Datenbank herzustellen, Abfragen auszuführen und Daten abzurufen.

2. Daten transformieren

Hier implementieren Sie Ihr entworfenes Schema. Sie müssen Code schreiben oder ein Tool verwenden, um:

• Zusammengehörige Datensätze gruppieren: Sammeln Sie beispielsweise alle OrderItems, die zu einer bestimmten Order gehören.
• Daten umstrukturieren: Konvertieren Sie relationale Zeilen in verschachtelte JSON-Dokumente.
• Datentypen behandeln: Stellen Sie sicher, dass Datentypen mit MongoDB kompatibel sind (z. B. Daten, Zahlen, Zeichenfolgen).

Beispiel mit Python:

Angenommen, Sie haben Customers, Orders und OrderItems in CSV-Dateien exportiert.

import pandas as pd
import json
from bson import ObjectId

# Daten aus CSV-Dateien laden (angenommen, sie befinden sich im selben Verzeichnis)
customers_df = pd.read_csv('customers.csv')
orders_df = pd.read_csv('orders.csv')
order_items_df = pd.read_csv('order_items.csv')

# --- Datenumwandlungslogik ---

# DataFrame in Wörterbücher konvertieren, um die Handhabung zu erleichtern
customers_list = customers_df.to_dict('records')
orders_list = orders_df.to_dict('records')
order_items_list = order_items_df.to_dict('records')

# Eine Zuordnung für Bestellungen und Bestellpositionen für schnellen Zugriff erstellen
orders_by_customer = {}
for order in orders_list:
    customer_id = order['CustomerID']
    if customer_id not in orders_by_customer:
        orders_by_customer[customer_id] = []
    orders_by_customer[customer_id].append(order)

order_items_by_order = {}
for item in order_items_list:
    order_id = item['OrderID']
    if order_id not in order_items_by_order:
        order_items_by_order[order_id] = []
    order_items_by_order[order_id].append(item)

# --- MongoDB-Dokumente erstellen (Option A: Kunde mit eingebetteten Bestellungen) ---
mongo_documents = []

for customer in customers_list:
    mongo_doc = {
        "_id": ObjectId(), # MongoDB generiert _id automatisch, aber Sie können es bei Bedarf zuordnen
        "customer_id": customer['CustomerID'],
        "first_name": customer['FirstName'],
        "last_name": customer['LastName'],
        "email": customer['Email'],
        "orders": []
    }

    customer_id = customer['CustomerID']
    if customer_id in orders_by_customer:
        for order in orders_by_customer[customer_id]:
            order_doc = {
                "order_id": order['OrderID'],
                "order_date": order['OrderDate'], # Stellen Sie das korrekte Datumsformat sicher
                "total_amount": order['TotalAmount'],
                "items": []
            }

            order_id = order['OrderID']
            if order_id in order_items_by_order:
                for item in order_items_by_order[order_id]:
                    order_doc['items'].append({
                        "product_id": item['ProductID'],
                        "quantity": item['Quantity'],
                        "price": item['Price']
                    })
            mongo_doc['orders'].append(order_doc)

    mongo_documents.append(mongo_doc)

# 'mongo_documents' ist jetzt eine Liste von Wörterbüchern, die zum Einfügen in MongoDB bereit sind
# print(json.dumps(mongo_documents[0], indent=2, default=str)) # Erstes Dokument als JSON ausgeben

# Für Option B (Separate Collections) würden Sie Listen für jede Collection erstellen:
# customers_mongo = [{'customer_id': c['CustomerID'], ...} for c in customers_list]
# orders_mongo = [{'order_id': o['OrderID'], 'customer_id': o['CustomerID'], ...} for o in orders_list]

# Für den Import in JSON speichern (optional)
# with open('mongo_customer_data.json', 'w') as f:
#     json.dump(mongo_documents, f, indent=2, default=str)

3. Tools für die Transformation

• Benutzerdefinierte Skripte: Python mit Pandas, Node.js mit Bibliotheken wie csv-parser und mysql/pg sind leistungsstark für komplexe Transformationen.
• ETL-Tools: Tools wie Apache NiFi, Talend oder AWS Glue können komplexe Datenpipelines orchestrieren, einschließlich der Migration von SQL zu MongoDB.
• Datenbankmigrationsplattformen: Einige kommerzielle ETL- und CDC-Tools können relationale Quellen mit MongoDB synchronisieren. Überprüfen Sie die Connector-Unterstützung für Ihre genaue SQL-Datenbank und Ihr MongoDB-Ziel, bevor Sie ein Tool in Ihre Planung einbeziehen.

Phase 3: Datenladen in MongoDB

Sobald Ihre Daten transformiert sind, können Sie sie in Ihre MongoDB-Instanz laden.

1. Verbindung zu MongoDB herstellen

Verwenden Sie die MongoDB-Shell (mongosh) oder einen MongoDB-Treiber (für Ihre Programmiersprache), um eine Verbindung zu Ihrer Datenbank herzustellen.

2. Transformierte Daten importieren

• Verwendung von mongoimport: Wenn Sie Ihre transformierten Daten in eine JSON-Datei exportiert haben, können Sie mongoimport verwenden:

  # Angenommen, Ihre Daten befinden sich in mongo_customer_data.json und Sie möchten sie in die 'customers'-Collection importieren
  mongoimport --db your_database_name --collection customers --file mongo_customer_data.json --jsonArray
  

  • --jsonArray: Verwenden Sie dieses Flag, wenn Ihre JSON-Datei ein Array von Dokumenten enthält.

• Verwendung von MongoDB-Treibern: Wenn Sie Ihre Datenstrukturen in Ihrer Programmiersprache generiert haben (wie die mongo_documents-Liste in Python), können Sie sie direkt einfügen:

  Python-Beispiel mit pymongo:

  from pymongo import MongoClient
  
  # Angenommen, die 'mongo_documents'-Liste ist aus dem vorherigen Python-Skript definiert
  client = MongoClient('mongodb://localhost:27017/')
  db = client['your_database_name']
  customers_collection = db['customers']
  
  # Die transformierten Dokumente einfügen
  if mongo_documents:
      insert_result = customers_collection.insert_many(mongo_documents)
      print(f"{len(insert_result.inserted_ids)} Dokumente eingefügt.")
  else:
      print("Keine Dokumente zum Einfügen.")
  
  client.close()
  

3. Datenintegrität überprüfen

Führen Sie nach dem Laden Abfragen in MongoDB durch, um zu überprüfen, ob die Daten korrekt importiert wurden und Ihren Erwartungen entsprechen.

// Beispiel: Anzahl der Dokumente in der 'customers'-Collection zählen
use your_database_name;
print(db.customers.countDocuments());

// Beispiel: Einen bestimmten Kunden finden und seine eingebetteten Bestellungen überprüfen
db.customers.findOne({ "customer_id": 1 })

Phase 4: Anwendungsrefaktorisierung

Dies ist wohl die zeitaufwändigste Phase. Ihr Anwendungscode muss aktualisiert werden, um mit MongoDB statt SQL zu interagieren.

• Datenbankverbindungen aktualisieren: Ändern Sie Verbindungszeichenfolgen und Bibliotheken.
• Abfragen umschreiben: Ersetzen Sie SQL-Abfragen durch die MongoDB-Abfragesprache mit der API Ihres gewählten Treibers.
• Datenzugriffsschicht anpassen: Ändern Sie Ihr ORM oder Ihre Datenzugriffsschicht, um mit MongoDB-Dokumenten zu arbeiten.
• MongoDB-Funktionen nutzen: Passen Sie Ihre Anwendung an, um Funktionen wie flexible Schemata, Aggregations-Framework und gegebenenfalls Geodatenabfragen zu nutzen.

Bewährte Methoden und Tipps

• Klein anfangen: Migrieren Sie wenn möglich zuerst eine Teilmenge Ihrer Daten oder eine weniger kritische Anwendung, um Erfahrung zu sammeln.
• Schema-Design iterieren: Ihr anfängliches MongoDB-Schema ist möglicherweise nicht perfekt. Seien Sie darauf vorbereitet, es basierend auf Leistungstests und Anwendungsfeedback zu iterieren und zu verfeinern.
• Mit Bedacht indizieren: Wie in SQL ist die Indizierung für die Leistung in MongoDB entscheidend. Identifizieren Sie Ihre Abfragemuster und erstellen Sie entsprechende Indizes.
• Leistung überwachen: Überwachen Sie kontinuierlich Ihre MongoDB-Bereitstellung auf Leistungsengpässe und optimieren Sie Abfragen und Schema nach Bedarf.
• Inkrementelle Migration in Betracht ziehen: Erwägen Sie für große Datenbanken eine inkrementelle Migrationsstrategie, bei der Änderungen von SQL zu MongoDB nahezu in Echtzeit synchronisiert werden, bevor Sie eine endgültige Umstellung durchführen.

Fazit

Die sicherste SQL-zu-MongoDB-Migration beginnt mit Zugriffsmustern, nicht mit Tabellennamen. Modellieren Sie einen wichtigen Workflow, transformieren Sie einen kleinen Datenausschnitt, laden Sie ihn in MongoDB, überprüfen Sie Anzahlen und Beispieldokumente, aktualisieren Sie dann den Anwendungscode für diese Struktur, bevor Sie die Migration skalieren.