Verknüpfen mit $lookup

Teil des Abschnitts Datenbanken mit MongoDB der Node.js-Journey von Coddy. Lektion 25 von 29.

Ein Buch speichert den Namen seines Autors, und die Angaben zum Autor befinden sich in einer anderen Collection. Der Client möchte beides in einer Antwort erhalten.

Die Stufe $lookup führt einen Join durch. Für jedes Dokument sucht sie die Dokumente in der Collection from, bei denen foreignField dem Wert von localField dieses Dokuments entspricht, und fügt sie in ein neues Array-Feld ein, dessen Name durch as festgelegt wird.

await orders.aggregate([
    { $match: { _id: orderId } },
    { $lookup: {
        from: 'customers',
        localField: 'customerEmail',
        foreignField: 'email',
        as: 'customer',
    } },
]).toArray();
// [{ _id: ..., customerEmail: 'ada@x.io', customer: [{ email: 'ada@x.io', ... }] }]

toArray() liefert ein Array mit Bestellungen, hier mit einer. Nimm das erste Element, um die Bestellung selbst zu erhalten.

localField gehört zu den Dokumenten in der Pipeline, foreignField zur anderen Collection. Das Ergebnis ist ein Array, auch wenn es nur einen Treffer gibt.

Die Collection from liefert jedes passende Dokument im Array, dessen Name durch as festgelegt wird. Die vorgegebene Route nimmt das erste Ergebnis der Pipeline, um das angeforderte Buch zurückzugeben.

Aufgabe

Einfach

In diesem Schritt wird das vorbereitete Bookshelf-API-Projekt des Kurses geöffnet, nicht deine Projektdateien aus Aggregation Pipelines (einschließlich server.js). Deine frühere Arbeit bleibt in ihrer eigenen Lektion. Lies die bereitgestellten Dateien, bevor du server.js bearbeitest. Diese Kopie enthält die Bookshelf-Routen sowie die Genre-Zählungen und die Pipeline für die am besten bewerteten Bücher, außerdem vorbereitete Autoren und die Behandlung der Antworten.

Füge in der vorbereiteten Route GET /books/:id/full in server.js nach dem vorhandenen Match eine Lookup-Stufe hinzu. Verknüpfe Autoren, indem book.author mit author.name übereinstimmt. Lege die Treffer in authorInfo ab. Lass den bereitgestellten Code unverändert, der das erste Ergebnis nimmt und bei einem fehlenden Buch 404 zurückgibt.

Probiere es aus: Rufe GET /books auf und kopiere Emma’s _id. GET /books/<Emma’s _id>/full gibt Emma mit einem authorInfo-Array zurück, das Jane Austen und born 1775 enthält. Bei einem Buch mit unbekanntem Autor wird authorInfo: [] zurückgegeben. Eine gültige, aber nicht vorhandene Buch-ID ergibt weiterhin 404.

Probier es selbst

import express from 'express';
import { MongoClient, ObjectId } from 'mongodb';
import { authorList } from './authors.js';

const client = new MongoClient('mongodb://localhost:27017');
const db = client.db('shelf');
const books = db.collection('books');
const ratings = db.collection('ratings');
const authors = db.collection('authors');

await books.createIndex({ isbn: 1 }, { unique: true });
await books.insertMany([
    { title: 'Dune', author: 'Frank Herbert', year: 1965, isbn: '9780441013593', genre: 'scifi' },
    { title: 'Kindred', author: 'Octavia E. Butler', year: 1979, isbn: '9780807083697', genre: 'scifi' },
    { title: 'Emma', author: 'Jane Austen', year: 1815, isbn: '9780141439587', genre: 'classic' },
]);
await authors.insertMany(authorList);

const app = express();
app.use(express.json());

// Jeder Fehler gibt { error: message } zurück.
function sendError(res, status, message) {
    res.status(status).json({ error: message });
}

// Die :id als ObjectId oder null, nachdem bei einer ungültigen id mit 400 geantwortet wurde.
function parseId(req, res) {
    if (ObjectId.isValid(req.params.id)) {
        return new ObjectId(req.params.id);
    }
    sendError(res, 400, 'Not a valid id');
    return null;
}

app.get('/', (req, res) => {
    res.send('Bookshelf API');
});

app.get('/books', async (req, res) => {
    const filter = {};
    if (req.query.author) {
        filter.author = req.query.author;
    }
    if (req.query.from || req.query.to) {
        filter.year = {};
        if (req.query.from) {
            filter.year.$gte = Number(req.query.from);
        }
        if (req.query.to) {
            filter.year.$lte = Number(req.query.to);
        }
    }
    const list = await books.find(filter).toArray();
    res.json(list);
});

app.post('/books', async (req, res) => {
    const book = req.body;
    try {
        await books.insertOne(book);
    } catch (err) {
        if (err.code === 11000) {
            return sendError(res, 409, 'That ISBN is already on the shelf');
        }
        throw err;
    }
    res.status(201).json(book);
});

app.get('/books/newest', async (req, res) => {
    const n = Number(req.query.n) || 3;
    const list = await books
        .find({}, { projection: { title: 1, year: 1, _id: 0 } })
        .sort({ year: -1 })
        .limit(n)
        .toArray();
    res.json(list);
});

app.get('/books/:id', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const book = await books.findOne({ _id: id });
    if (!book) {
        return sendError(res, 404, 'No such book');
    }
    res.json(book);
});

app.patch('/books/:id', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const result = await books.updateOne({ _id: id }, { $set: req.body });
    if (result.matchedCount === 0) {
        return sendError(res, 404, 'No such book');
    }
    res.json(await books.findOne({ _id: id }));
});

app.post('/books/:id/copies', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const result = await books.updateOne({ _id: id }, { $inc: { copies: 1 } });
    if (result.matchedCount === 0) {
        return sendError(res, 404, 'No such book');
    }
    res.json(await books.findOne({ _id: id }));
});

app.post('/books/:id/tags', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const result = await books.updateOne({ _id: id }, { $push: { tags: req.body.tag } });
    if (result.matchedCount === 0) {
        return sendError(res, 404, 'No such book');
    }
    res.json(await books.findOne({ _id: id }));
});

app.delete('/books/:id', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const result = await books.deleteOne({ _id: id });
    if (result.deletedCount === 0) {
        return sendError(res, 404, 'No such book');
    }
    res.status(204).end();
});

app.put('/books/:id/ratings', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const { user, stars } = req.body;
    await ratings.updateOne({ bookId: id, user }, { $set: { stars } }, { upsert: true });
    res.json({ user, stars });
});

app.get('/books/:id/ratings', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    res.json(await ratings.find({ bookId: id }).toArray());
});

app.get('/stats', async (req, res) => {
    const filter = req.query.genre ? { genre: req.query.genre } : {};
    res.json({
        books: await books.countDocuments(filter),
        ratings: await ratings.countDocuments(),
    });
});

app.get('/stats/genres', async (req, res) => {
    const genres = await books
        .aggregate([{ $group: { _id: '$genre', count: { $sum: 1 } } }])
        .toArray();
    res.json(genres);
});

app.get('/stats/top', async (req, res) => {
    const top = await ratings
        .aggregate([
            { $group: { _id: '$bookId', avg: { $avg: '$stars' }, count: { $sum: 1 } } },
            { $match: { count: { $gte: 2 } } },
            { $sort: { avg: -1 } },
            { $limit: 3 },
        ])
        .toArray();
    res.json(top);
});

app.get('/books/:id/full', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const [book] = await books
        .aggregate([
            { $match: { _id: id } },

        ])
        .toArray();
    if (!book) {
        return sendError(res, 404, 'No such book');
    }
    res.json(book);
});

app.listen(3000, () => {
    console.log('Bookshelf is running on port 3000');
});

Übe selbstständig: Express-Playground

Verknüpfen mit $lookup

Alle Lektionen in Datenbanken mit MongoDB