MongoDB-Produkt-Daten strukturieren

Einführung

In diesem Lab lernst du, wie du ein strukturiertes MongoDB-Dokumentschema für Produkt-Daten in einem E-Commerce-System entwirfst. Das Lab behandelt die wesentlichen Schritte, darunter das Erstellen eines Produktschemas, Hinzufügen von Kategorieinformationen, einschließlich Preisdetails, Einstellen der Lagerbestände und Verfolgen des Produktstatus. Am Ende dieses Labs wirst du eine umfassende Vorstellung davon haben, wie du Produkt-Daten effektiv in einer MongoDB-Datenbank modellierst.

Das Lab beginnt mit der Erstellung eines Produktschemas, das verschiedene Produkt-Details wie Namen, Kategorie, Marke, Preise, Lagerinformationen, Spezifikationen und Metadaten aufnimmt. Du wirst lernen, wie du die flexible Dokumentstruktur von MongoDB nutzen kannst, um komplexe Produkt-Daten darzustellen. Darüber hinaus zeigt das Lab, wie du den Produktstatus verwalten und effizientes Filtern und Anzeigen von Produktinformationen ermöglichen kannst.

Produkt-Schema erstellen

In diesem Schritt lernst du, wie du ein strukturiertes MongoDB-Dokumentschema für Produkt-Daten entwirfst. Wir werden ein flexibles und umfassendes Schema erstellen, das verschiedene Produkttypen in einem E-Commerce-System darstellen kann.

Zunächst starten wir die MongoDB-Shell:

mongosh

Jetzt erstellen wir eine Datenbank für unseren Produktkatalog:

use product_catalog

Wir werden ein Produktschema entwerfen, das mehrere Felder enthält, um umfassende Produktinformationen zu erfassen:

db.products.insertOne({
  name: "Wireless Noise-Canceling Headphones",
  category: "Electronics",
  subcategory: "Audio",
  brand: "TechSound",
  price: {
    base: 199.99,
    currency: "USD",
    discount: {
      percentage: 10,
      active: true
    }
  },
  stock: {
    total: 500,
    available: 450,
    warehouse: "Main Distribution Center"
  },
  specifications: {
    color: ["Black", "Silver"],
    batteryLife: "30 hours",
    connectivity: ["Bluetooth 5.0", "3.5mm Jack"]
  },
  status: {
    inStock: true,
    featured: false,
    new: true
  },
  metadata: {
    sku: "TECH-SOUND-NC-001",
    dateAdded: new Date(),
    lastUpdated: new Date()
  }
});

Zergliedern wir das Schema:

1. Grundlegende Produktinformationen:

   • name: Produktbezeichnung
   • category und subcategory: Hierarchische Klassifizierung
   • brand: Herstellerinformation

2. Preisdetails:

   • Verschachteltes price-Objekt mit Grundpreis, Währung und Rabattinformation

3. Lagerverwaltung:

   • stock-Objekt zur Verfolgung der gesamten und verfügbaren Bestände
   • Lagerort

4. Produkt-Spezifikationen:

   • Flexibles specifications-Objekt für detaillierte Produktattribute
   • Unterstützt mehrere Werte (wie Farben)

5. Produktstatus:

   • status-Objekt für schnelles Filtern und Anzeigelogik

6. Metadaten:

   • Verfolgung zusätzlicher Informationen wie SKU und Zeitstempel

Um unser Dokument zu überprüfen, holen wir es ab:

db.products.find({ name: "Wireless Noise-Canceling Headphones" });

Kategorieinformationen hinzufügen

In diesem Schritt erweitern wir unser Produktschema, indem wir ein umfassendes Kategoriemanagementsystem erstellen. Wir werden zeigen, wie wir detaillierte Kategorieinformationen zu unseren Produkt-Dokumenten hinzufügen und eine separate Kategorien-Sammlung erstellen, um eine bessere Organisation zu gewährleisten.

Zunächst setzen wir in der MongoDB-Shell fort:

mongosh product_catalog

Lassen Sie uns eine separate Kategorien-Sammlung erstellen, um die Produktkategorien hierarchisch zu verwalten:

db.categories.insertMany([
  {
    _id: "electronics",
    name: "Electronics",
    description: "All electronic devices and gadgets",
    parent: null,
    subcategories: ["audio", "computers", "smartphones"]
  },
  {
    _id: "audio",
    name: "Audio",
    description: "Sound and audio equipment",
    parent: "electronics",
    attributes: ["wireless", "noise-canceling", "battery-life", "connectivity"]
  }
]);

Jetzt aktualisieren wir unser vorheriges Produkt-Dokument, um auf diese Kategorien zu verweisen:

db.products.updateOne(
  { name: "Wireless Noise-Canceling Headphones" },
  {
    $set: {
      categoryRef: {
        main: "electronics",
        sub: "audio"
      },
      categoryDetails: {
        path: ["electronics", "audio"],
        taxonomyVersion: "1.0"
      }
    }
  }
);

Lassen Sie uns das aktualisierte Produkt-Dokument überprüfen:

db.products.findOne({ name: "Wireless Noise-Canceling Headphones" });

Dieser Ansatz bietet mehrere Vorteile:

1. Separate Kategoriemanagement
2. Hierarchische Kategorienstruktur
3. Flexible Attributverfolgung
4. Einfache Kategorisierung und Filterung

Preisdetails einbeziehen

In diesem Schritt erweitern wir unser Produktschema, indem wir eine umfassende Preissstruktur erstellen, die mehrere Preis-Szenarien und Währungsverwaltung unterstützt.

Zunächst setzen wir in der MongoDB-Shell fort:

mongosh product_catalog

Wir werden ein detaillierteres Preismodell mit mehreren Preisstrategien erstellen:

db.products.updateOne(
  { name: "Wireless Noise-Canceling Headphones" },
  {
    $set: {
      pricing: {
        base: {
          amount: 199.99,
          currency: "USD"
        },
        retail: {
          amount: 219.99,
          currency: "USD"
        },
        discounts: [
          {
            type: "SEASONAL",
            percentage: 10,
            startDate: new Date("2024-01-01"),
            endDate: new Date("2024-01-31")
          },
          {
            type: "LOYALTY",
            percentage: 5,
            conditions: "For members with 1+ year membership"
          }
        ],
        taxRates: {
          standard: 0.08,
          reduced: 0.05
        },
        priceHistory: [
          {
            date: new Date("2023-12-01"),
            amount: 189.99
          },
          {
            date: new Date("2024-01-01"),
            amount: 199.99
          }
        ]
      }
    }
  }
);

Lassen Sie uns eine separate Preis-Sammlung für komplexere Preisstrategien erstellen:

db.pricing_rules.insertOne({
  productId: "TECH-SOUND-NC-001",
  dynamicPricing: {
    enabled: true,
    algorithm: "supply-demand",
    minPrice: 150.0,
    maxPrice: 250.0
  },
  bulkPricing: [
    {
      quantity: { min: 1, max: 10 },
      discount: 0
    },
    {
      quantity: { min: 11, max: 50 },
      discount: 0.05
    },
    {
      quantity: { min: 51 },
      discount: 0.1
    }
  ]
});

Überprüfen Sie die aktualisierten Produktpreise:

db.products.findOne({ name: "Wireless Noise-Canceling Headphones" });

Lagerbestände festlegen

In diesem Schritt entwickeln wir ein sophistiziertes Lagersystem zur Verfolgung des Produktbestands über mehrere Lager und Standorte.

Zunächst setzen wir in der MongoDB-Shell fort:

mongosh product_catalog

Wir werden ein umfassendes Lagerschemas erstellen:

db.products.updateOne(
  { name: "Wireless Noise-Canceling Headphones" },
  {
    $set: {
      inventory: {
        total: {
          quantity: 1000,
          unit: "pieces"
        },
        warehouses: [
          {
            name: "Main Distribution Center",
            location: "New York",
            quantity: 500,
            status: "primary"
          },
          {
            name: "West Coast Warehouse",
            location: "Los Angeles",
            quantity: 300,
            status: "secondary"
          },
          {
            name: "Online Fulfillment Center",
            location: "Chicago",
            quantity: 200,
            status: "backup"
          }
        ],
        tracking: {
          minimumStockLevel: 100,
          restockThreshold: 250,
          lastRestocked: new Date()
        },
        reservations: [
          {
            type: "online_orders",
            quantity: 50,
            reservedUntil: new Date(Date.now() + 24 * 60 * 60 * 1000)
          }
        ]
      }
    }
  }
);

Lassen Sie uns eine separate Lagerschemasammlung erstellen:

db.inventory_logs.insertOne({
  productId: "TECH-SOUND-NC-001",
  transactionHistory: [
    {
      date: new Date(),
      type: "initial_stock",
      quantity: 1000,
      source: "manufacturer",
      notes: "Initial product launch inventory"
    }
  ],
  stockAdjustments: [
    {
      date: new Date(),
      reason: "Seasonal Preparation",
      quantityAdjusted: 100,
      direction: "increase"
    }
  ]
});

Überprüfen Sie den aktualisierten Produktbestand:

db.products.findOne({ name: "Wireless Noise-Canceling Headphones" });

Produktstatus verfolgen

In diesem Schritt implementieren wir ein umfassendes Produktstatus-Verfolgungssystem, das detaillierte Einblicke in den Produktlebenszyklus, den Marketingstatus und die Leistungsmessgrößen bietet.

Zunächst setzen wir in der MongoDB-Shell fort:

mongosh product_catalog

Wir aktualisieren unser Produkt-Dokument mit einem fortgeschrittenen Status-Verfolgungsmechanismus:

db.products.updateOne(
  { name: "Wireless Noise-Canceling Headphones" },
  {
    $set: {
      productStatus: {
        lifecycle: {
          stage: "aktiv",
          introduced: new Date("2024-01-01"),
          expectedEndOfLife: new Date("2025-12-31")
        },
        marketingStatus: {
          featured: true,
          newArrival: false,
          onSale: true,
          promotionActive: true
        },
        performanceMetrics: {
          salesVolume: {
            monatlich: 1500,
            vierteljährlich: 4500,
            jährlich: 18000
          },
          customerRatings: {
            durchschnittlich: 4.7,
            Gesamtbewertungen: 250,
            Empfehlungswert: 0.92
          }
        },
        complianceAndCertification: {
          regulatorische Genehmigungen: ["FCC", "CE", "RoHS"],
          Garantieinformation: {
            Dauer: "2 Jahre",
            Typ: "Hersteller"
          }
        },
        digitalPresence: {
          Website Sichtbarkeit: {
            Seitenaufrufe: 50000,
            einzigartige Besucher: 15000
          },
          E-Commerce-Plattformen: ["company_website", "amazon", "best_buy"]
        }
      }
    }
  }
);

Erstellen Sie eine separate Sammlung für die Produktstatus-Verfolgung und historische Daten:

db.product_status_history.insertOne({
  productId: "TECH-SOUND-NC-001",
  statusChanges: [
    {
      date: new Date(),
      previousStatus: "entwicklung",
      newStatus: "aktiv",
      reason: "Produktstart",
      updatedBy: "product_management_team"
    }
  ],
  performanceSnapshots: [
    {
      date: new Date(),
      salesVolume: 1500,
      customerSatisfaction: 4.7
    }
  ]
});

Überprüfen Sie den aktualisierten Produktstatus:

db.products.findOne({ name: "Wireless Noise-Canceling Headphones" });

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie ein strukturiertes MongoDB-Dokumentschema für Produkt-Daten entwerfen. Sie haben ein flexibles und umfassendes Schema erstellt, das verschiedene Produkttypen in einem E-Commerce-System darstellen kann. Das Schema umfasst Felder für grundlegende Produktinformationen, Preisdetails, Lagersverwaltung, Produkt-Spezifikationen, Status und Metadaten. Dies ermöglicht die effiziente Speicherung und Abrufung von detaillierten Produkt-Daten in einer MongoDB-Datenbank.

Das Schema deckt die wichtigsten Aspekte von Produkt-Daten ab, wie hierarchische Kategorisierung, Preise mit Rabatten, Lagersverfolgung, detaillierte Spezifikationen und Statusindikatoren. Dieser strukturierte Ansatz ermöglicht eine effektive Produktverwaltung und unterstützt verschiedene Anwendungsfälle in einer E-Commerce-Anwendung.