Przykłady i ograniczenia potoku agregacji

Ważna

Czy chcesz przeprowadzić migrację istniejącej aplikacji bazy danych MongoDB lub używać funkcji języka zapytań MongoDB (MQL)? Rozważ użycie usługi Azure DocumentDB.

Szukasz rozwiązania bazy danych dla scenariuszy o dużej skali z umową SLA gwarantującą poziom dostępności na poziomie 99,999%, natychmiastowym skalowaniem automatycznym i automatycznym przełączaniem awaryjnym między wieloma regionami? Rozważmy usługę Azure Cosmos DB dla noSQL.

Potok agregacji umożliwia przeprowadzanie zaawansowanej analizy danych i przekształcania kolekcji w usłudze Azure Cosmos DB for MongoDB. Potok to sekwencja etapów, z których każdy filtruje, zmienia kształt lub oblicza wartości w dokumentach przepływających przez nie. W tym artykule przedstawiono typowe wzorce potoków pojedynczej kolekcji, objaśniono ograniczenia dotyczące agregacji między kolekcjami przy użyciu $lookup i zasugerowano obejścia, gdy agregacja natywna nie jest wystarczająca.

Prerequisites

  • Konto Azure Cosmos DB dla MongoDB. Jeśli go nie masz, utwórz konto.
  • Klient lub powłoka zgodna z bazą danych MongoDB połączony z Twoim kontem.

Składnia podstawowa

db.<collection>.aggregate([
    { <stage1> },
    { <stage2> },
    // ...
    { <stageN> }
])

Każdy etap odbiera dokumenty wyjściowe z poprzedniego etapu i przekazuje własne dane wyjściowe do następnego.

Przykłady potoku dla pojedynczej kolekcji

Przykłady w tej sekcji używają sales kolekcji z dokumentami w następującym formacie:

{
  "_id": "ord-001",
  "date": "2024-03-15",
  "category": "electronics",
  "item": "laptop",
  "price": 1200,
  "quantity": 2,
  "tags": ["sale", "featured"]
}

Filtrowanie dokumentów przy użyciu $match

Służy $match do przekazywania tylko dokumentów spełniających warunek. Umieść $match tak wcześnie, jak to możliwe w potoku, aby można było używać indeksów i zmniejszyć liczbę dokumentów przetwarzanych przez późniejsze etapy.

db.sales.aggregate([
    { $match: { category: "electronics", price: { $gt: 500 } } }
])

Grupowanie i obliczanie sum za pomocą $group

Służy $group do grupowania dokumentów według pola i stosowania wyrażeń akumulatorowych, takich jak $sum, $avg, $mini $max.

db.sales.aggregate([
    {
        $group: {
            _id: "$category",
            totalRevenue: { $sum: { $multiply: ["$price", "$quantity"] } },
            orderCount: { $sum: 1 },
            avgPrice: { $avg: "$price" }
        }
    }
])

Kształtowanie danych wyjściowych za pomocą $project

Służy $project do dołączania, wykluczania lub obliczania pól w dokumentach wyjściowych. Ustaw pole na 1, aby je uwzględnić, na 0, aby je wykluczyć, lub podaj wyrażenie, aby obliczyć nową wartość.

db.sales.aggregate([
    {
        $project: {
            item: 1,
            price: 1,
            revenue: { $multiply: ["$price", "$quantity"] },
            discounted: { $cond: [{ $gt: ["$price", 1000] }, true, false] }
        }
    }
])

Sortowanie wyników za pomocą $sort

Służy $sort do zamawiania dokumentów według co najmniej jednego pola. Użyj polecenia 1 dla kolejności rosnącej i -1 kolejności malejącej.

db.sales.aggregate([
    { $sort: { price: -1, date: 1 } }
])

Ogranicz wyniki za pomocą $limit i $skip

Użyj $limit polecenia , aby ograniczyć liczbę dokumentów wyjściowych. Użyj $skip polecenia , aby pominąć określoną liczbę dokumentów, co jest przydatne w przypadku stronicowania w połączeniu z elementem $sort.

db.sales.aggregate([
    { $sort: { date: -1 } },
    { $skip: 20 },
    { $limit: 10 }
])

Spłaszczanie tablic za pomocą $unwind

Służy $unwind do dekonstrukcji pola tablicy, aby każdy element tworzy oddzielny dokument wyjściowy.

db.sales.aggregate([
    { $unwind: "$tags" },
    { $group: { _id: "$tags", count: { $sum: 1 } } },
    { $sort: { count: -1 } }
])

Dodawanie obliczonych pól przy użyciu $addFields

Użyj $addFields, aby dodać nowe pola do dokumentów bez konieczności ponownego określania wszystkich istniejących pól, w przeciwieństwie do $project.

db.sales.aggregate([
    {
        $addFields: {
            totalValue: { $multiply: ["$price", "$quantity"] },
            year: { $substr: ["$date", 0, 4] }
        }
    }
])

Przykład wieloetapowego ciągu

Poniższy potok łączy kilka etapów, aby znaleźć pięć najważniejszych kategorii produktów według łącznego przychodu w pierwszym kwartale 2024 r.:

db.sales.aggregate([
    // Stage 1: filter to Q1 2024
    { $match: { date: { $gte: "2024-01-01", $lt: "2024-04-01" } } },

    // Stage 2: compute per-document revenue
    { $addFields: { revenue: { $multiply: ["$price", "$quantity"] } } },

    // Stage 3: group by category and sum revenue
    { $group: { _id: "$category", totalRevenue: { $sum: "$revenue" } } },

    // Stage 4: sort by revenue descending
    { $sort: { totalRevenue: -1 } },

    // Stage 5: return top 5 only
    { $limit: 5 },

    // Stage 6: rename _id for readability
    { $project: { _id: 0, category: "$_id", totalRevenue: 1 } }
])

Agregacja między kolekcjami za pomocą $lookup

Etap $lookup wykonuje lewe sprzężenia zewnętrzne między bieżącą kolekcją (lokalną) a inną kolekcją (obcą) w tej samej bazie danych. Poniższy przykład łączy orders z kolekcją customers przy użyciu pasującego pola.

db.orders.aggregate([
    {
        $lookup: {
            from: "customers",
            localField: "customerId",
            foreignField: "_id",
            as: "customerInfo"
        }
    },
    { $unwind: "$customerInfo" },
    {
        $project: {
            orderId: "$_id",
            customerName: "$customerInfo.name",
            total: 1
        }
    }
])

$lookup ograniczenia dotyczące usługi Azure Cosmos DB dla bazy danych MongoDB

$lookup jest częściowo obsługiwany w Azure Cosmos DB dla bazy danych MongoDB. Następujące ograniczenia dotyczą wszystkich obsługiwanych wersji serwera:

  • Podzapytania nieskorelowane nie są obsługiwane. Rozszerzona składnia $lookup wprowadzona w MongoDB 3.6, wykorzystująca pola let i pipeline, nie jest obsługiwana. Użycie tych pól zwraca błąd "letnie jest obsługiwany". Zamiast tego użyj formularza podstawowegofromforeignField / aslocalField / / .

    // This syntax is NOT supported:
    {
        $lookup: {
            from: "inventory",
            let: { ordItem: "$item" },
            pipeline: [ { $match: { $expr: { $eq: ["$sku", "$$ordItem"] } } } ],
            as: "inventoryDocs"
        }
    }
    
  • $graphLookup nie jest obsługiwane w wersjach interfejsu API 4.2, 6.0 i 7.0. Jeśli obciążenie wymaga rekurencyjnych lub zapytań przechodzenia grafu, zobacz Obejścia scenariuszy obejmujących wiele kolekcji.

  • Obie kolekcje muszą znajdować się w tej samej bazie danych. Operacje międzybazodanowe $lookup nie są obsługiwane.

  • Zagadnienia dotyczące wydajności. Ponieważ Azure Cosmos DB dla bazy danych MongoDB jest systemem rozproszonym, $lookup sprzężenia obejmujące duże kolekcje lub kolekcje w oddzielnych partycjach logicznych mogą zużywać znaczące jednostki żądań (RU). Oceń użycie jednostek RU za pomocą planisty pojemności i rozważ denormalizowanie danych w celu zmniejszenia częstotliwości operacji join.

Ograniczenia agregacji między kolekcjami

Azure Cosmos DB dla bazy danych MongoDB jest zoptymalizowany pod kątem wzorców dostępu do pojedynczej kolekcji o wysokiej przepływności. Jeśli musisz agregować dane w wielu kolekcjach, pamiętaj o następujących ograniczeniach:

Capability Support
Podstawowe $lookup (localField / foreignField) ✅ Tak
$lookup z let i pipeline (nieskorelowane podzapytania) ✖️ Nie
$graphLookup (przechodzenie grafu) ✖️ Nie (wersje 4.2–7.0)
$lookup między bazami danych ✖️ Nie
Transakcje obejmujące wiele kolekcji ✖️ Nie (transakcje wielodokumentowe są ograniczone do pojedynczej niefragmentowanej kolekcji)

Te ograniczenia mają zastosowanie niezależnie od używanej wersji serwera (od 3.6 do 7.0).

Obejścia dla scenariuszy między kolekcjami

Jeśli natywne możliwości potoku agregacji nie są wystarczające dla scenariusza obejmującego wiele kolekcji lub eksportu, rozważ następujące alternatywy.

Agregacja po stronie aplikacji

Wykonaj zapytania dotyczące każdej kolekcji niezależnie, a następnie połącz i zagreguj wyniki w aplikacji. Takie podejście pozwala uniknąć $lookup ograniczeń i zapewnia pełną kontrolę nad logiką sprzężenia.

// Query collection A
const orders = await db.collection("orders").find({ status: "completed" }).toArray();
const customerIds = orders.map(o => o.customerId);

// Query collection B with matching IDs
const customers = await db.collection("customers")
    .find({ _id: { $in: customerIds } })
    .toArray();

// Join in application memory
const customerMap = new Map(customers.map(c => [c._id.toString(), c]));
const enriched = orders.map(o => ({
    ...o,
    customer: customerMap.get(o.customerId.toString())
}));

Ten wzorzec jest najbardziej odpowiedni dla zestawów wyników od małych do średnich. W przypadku dużych eksportów użyj jednej z integracji usług Azure opisanych w dalszej części.

Usługa Azure Synapse Link dla Azure Cosmos DB automatycznie synchronizuje dane operacyjne z Azure Synapse Analytics bez wpływu na obciążenia transakcyjne. W Azure Synapse można uruchamiać zapytania analityczne obejmujące wiele kolekcji przy użyciu platformy Apache Spark lub bezserwerowych pul SQL, które obsługują semantykę pełnego sprzężenia.

Jeśli potrzebujesz, użyj usługi Azure Synapse Link:

  • Złożone zapytania analityczne w wielu kolekcjach.
  • Analiza trendów historycznych lub raportowanie bez wpływu na użycie jednostek RU w środowisku produkcyjnym.
  • Analiza w czasie zbliżonym do rzeczywistego z minimalnym obciążeniem ETL.

Azure Data Factory na potrzeby eksportowania i przekształcania

Azure Data Factory może odczytywać z wielu Azure Cosmos DB dla kolekcji bazy danych MongoDB, stosować przekształcenia w przepływach danych i zapisywać wyniki w miejscu docelowym, takim jak Azure Blob Storage, Azure SQL Database lub Azure Synapse Analytics.

Jeśli potrzebujesz, użyj Azure Data Factory:

  • Zaplanowane eksportowanie danych wsadowych z jednej lub większej liczby kolekcji.
  • Złączenia między kolekcjami w ramach potoku ETL.
  • Integracja z systemami podrzędnymi, które nie łączą się bezpośrednio z Azure Cosmos DB.