Zum Hauptinhalt springen

MongoDB

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

MongoDB-Unterstützung​

TypeORM bietet grundlegende MongoDB-Unterstützung. Der Großteil der TypeORM-Funktionalität ist RDBMS-spezifisch. Diese Seite enthält die gesamte Dokumentation zur MongoDB-spezifischen Funktionalität.

Installation​

npm install mongodb

Datenquellen-Optionen​

  • url - Verbindungs-URL, über die die Verbindung hergestellt wird. Beachten Sie, dass andere Datenquellen-Optionen Parameter aus der URL überschreiben.

  • host - Datenbank-Host.

  • port - Port des Datenbank-Hosts. Der Standard-MongoDB-Port ist 27017.

  • username - Datenbank-Benutzername (Ersatz für auth.user).

  • password - Datenbank-Passwort (Ersatz für auth.password).

  • database - Datenbankname.

  • poolSize - Legt die maximale Pool-Größe für jede Server- oder Proxy-Verbindung fest.

  • tls - Verwendet eine TLS/SSL-Verbindung (erfordert einen mongod-Server mit SSL-Unterstützung, Version 2.4 oder höher). Standard: false.

  • tlsAllowInvalidCertificates - Legt fest, ob der Treiber einen Fehler generiert, wenn das TLS-Zertifikat des Servers ungültig ist. Standard: false.

  • tlsCAFile - Gibt den Speicherort einer lokalen .pem-Datei an, die die Stammzertifikatskette der Zertifizierungsstelle enthält.

  • tlsCertificateKeyFile - Gibt den Speicherort einer lokalen .pem-Datei an, die das TLS/SSL-Zertifikat und den Schlüssel des Clients enthält.

  • tlsCertificateKeyFilePassword - Gibt das Passwort zur Entschlüsselung der tlsCertificateKeyFile an.

  • keepAlive - Wartezeit in Millisekunden vor Initiierung von keepAlive auf dem TCP-Socket. Standard: 30000.

  • connectTimeoutMS - Timeout-Einstellung für TCP-Verbindungen. Standard: 30000.

  • socketTimeoutMS - Timeout-Einstellung für TCP-Sockets. Standard: 360000.

  • replicaSet - Name des Replica Sets, zu dem verbunden werden soll.

  • authSource - Falls die Datenbank-Authentifizierung von einem anderen Datenbanknamen abhängt.

  • writeConcern - Die Schreibbestätigungseinstellung (Write Concern).

  • forceServerObjectId - Erzwingt, dass der Server _id-Werte vergibt statt des Treibers. Standard: false.

  • serializeFunctions - Serialisiert Funktionen in beliebigen Objekten. Standard: false.

  • ignoreUndefined - Legt fest, ob der BSON-Serializer undefinierte Felder ignorieren soll. Standard: false.

  • raw - Gibt Dokumentenergebnisse als rohe BSON-Puffer zurück. Standard: false.

  • promoteLongs - Erhöht Long-Werte zu Zahlen, wenn sie in die 53-Bit-Genauigkeit passen. Standard: true.

  • promoteBuffers - Erhöht Binary-BSON-Werte zu nativen Node.js-Buffern. Standard: false.

  • promoteValues - Erhöht BSON-Werte zu nativen Typen wo möglich. Auf false setzen, um nur Wrappertypen zu erhalten. Standard: true.

  • readPreference - Die bevorzugte Lesepräferenz:

    • ReadPreference.PRIMARY
    • ReadPreference.PRIMARY_PREFERRED
    • ReadPreference.SECONDARY
    • ReadPreference.SECONDARY_PREFERRED
    • ReadPreference.NEAREST

  • pkFactory - Eine Primary-Key-Factory für die Generierung benutzerdefinierter _id-Schlüssel.

  • readConcern - Legt eine Leseisolationsebene (Read Concern) für die Collection fest (nur MongoDB 3.2 oder höher).

  • maxStalenessSeconds - Legt einen maxStalenessSeconds-Wert für Lesevorgänge von Secondaries fest (Minimum 90 Sekunden).

  • appName - Der Name der Anwendung, die diese MongoClient-Instanz erstellt hat. MongoDB 3.4+ protokolliert diesen Wert im Server-Log bei jeder Verbindung. Er erscheint auch im Slow-Query-Log und Profil-Collections.

  • authMechanism - Legt den Authentifizierungsmechanismus fest, den MongoDB für die Verbindung verwendet.

  • directConnection - Legt fest, ob alle Operationen zwangsweise an den angegebenen Host gesendet werden sollen.

Zusätzliche Optionen können im extra-Objekt hinzugefügt werden und werden direkt an die Client-Bibliothek übergeben. Weitere Details finden Sie in der Dokumentation zu mongodb unter Connection Options.

Definieren von Entitäten und Spalten​

Das Definieren von Entitäten und Spalten funktioniert fast identisch wie in relationalen Datenbanken. Der Hauptunterschied besteht darin, dass Sie @ObjectIdColumn anstelle von @PrimaryColumn oder @PrimaryGeneratedColumn verwenden müssen.

Einfaches Entitätsbeispiel:

import { Entity, ObjectId, ObjectIdColumn, Column } from "typeorm"

@Entity()
export class User {
    @ObjectIdColumn()
    _id: ObjectId

    @Column()
    firstName: string

    @Column()
    lastName: string
}

So initialisieren Sie die Anwendung:

import { DataSource } from "typeorm"

const myDataSource = new DataSource({
    type: "mongodb",
    host: "localhost",
    port: 27017,
    database: "test",
})

Definieren von Unterdokumenten (eingebettete Dokumente)​

Da MongoDB Objekte innerhalb von Objekten speichert (oder Dokumente innerhalb von Dokumenten), können Sie dies auch in TypeORM umsetzen:

import { Entity, ObjectId, ObjectIdColumn, Column } from "typeorm"

export class Profile {
    @Column()
    about: string

    @Column()
    education: string

    @Column()
    career: string
}
import { Entity, ObjectId, ObjectIdColumn, Column } from "typeorm"

export class Photo {
    @Column()
    url: string

    @Column()
    description: string

    @Column()
    size: number

    constructor(url: string, description: string, size: number) {
        this.url = url
        this.description = description
        this.size = size
    }
}
import { Entity, ObjectId, ObjectIdColumn, Column } from "typeorm"

@Entity()
export class User {
    @ObjectIdColumn()
    id: ObjectId

    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column((type) => Profile)
    profile: Profile

    @Column((type) => Photo)
    photos: Photo[]
}

Wenn Sie diese Entität speichern:

import { getMongoManager } from "typeorm"

const user = new User()
user.firstName = "Timber"
user.lastName = "Saw"
user.profile = new Profile()
user.profile.about = "About Trees and Me"
user.profile.education = "Tree School"
user.profile.career = "Lumberjack"
user.photos = [
    new Photo("me-and-trees.jpg", "Me and Trees", 100),
    new Photo("me-and-chakram.jpg", "Me and Chakram", 200),
]

const manager = getMongoManager()
await manager.save(user)

Wird folgendes Dokument in der Datenbank gespeichert:

{
    "firstName": "Timber",
    "lastName": "Saw",
    "profile": {
        "about": "About Trees and Me",
        "education": "Tree School",
        "career": "Lumberjack"
    },
    "photos": [
        {
            "url": "me-and-trees.jpg",
            "description": "Me and Trees",
            "size": 100
        },
        {
            "url": "me-and-chakram.jpg",
            "description": "Me and Chakram",
            "size": 200
        }
    ]
}

Verwendung von MongoEntityManager und MongoRepository​

Sie können die meisten Methoden des EntityManager verwenden (außer RDBMS-spezifischen wie query und transaction). Beispiel:

const timber = await myDataSource.manager.findOneBy(User, {
    firstName: "Timber",
    lastName: "Saw",
})

Für MongoDB gibt es zusätzlich einen separaten MongoEntityManager, der den EntityManager erweitert.

const timber = await myDataSource.manager.findOneBy(User, {
    firstName: "Timber",
    lastName: "Saw",
})

Ähnlich wie beim MongoEntityManager existiert ein MongoRepository mit erweitertem Repository:

const timber = await myDataSource.getMongoRepository(User).findOneBy({
    firstName: "Timber",
    lastName: "Saw",
})

Erweiterte Optionen in find() nutzen:

Gleich:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        firstName: { $eq: "Timber" },
    },
})

Kleiner als:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        age: { $lt: 60 },
    },
})

In:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        firstName: { $in: ["Timber", "Zhang"] },
    },
})

Nicht in:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        firstName: { $not: { $in: ["Timber", "Zhang"] } },
    },
})

Oder:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        $or: [{ firstName: "Timber" }, { firstName: "Zhang" }],
    },
})

Abfragen von Unterdokumenten

const users = await myDataSource.getMongoRepository(User).find({
    where: {
        "profile.education": { $eq: "Tree School" },
    },
})

Abfragen von Unterdokument-Arrays

// Query users with photos of size less than 500
const users = await myDataSource.getMongoRepository(User).find({
    where: {
        "photos.size": { $lt: 500 },
    },
})

Sowohl MongoEntityManager als auch MongoRepository bieten viele nützliche MongoDB-spezifische Methoden:

createCursor​

Erstellt einen Cursor für eine Abfrage, der zum Durchlaufen von MongoDB-Ergebnissen verwendet werden kann.

createEntityCursor​

Erstellt einen Cursor für eine Abfrage, der zum Durchlaufen von MongoDB-Ergebnissen dient. Dieser gibt eine modifizierte Cursor-Version zurück, die jedes Ergebnis in Entitätsmodelle umwandelt.

aggregate​

Führt ein Aggregation Framework-Pipeline gegen die Sammlung aus.

bulkWrite​

Führt eine bulkWrite-Operation ohne fluent API durch.

count​

Zählt die Anzahl passender Dokumente in der Datenbank für eine Abfrage.

countDocuments​

Zählt die Anzahl passender Dokumente in der Datenbank für eine Abfrage.

createCollectionIndex​

Erstellt einen Index für die Datenbank und Sammlung.

createCollectionIndexes​

Erstellt mehrere Indizes in der Sammlung. Diese Methode wird nur in MongoDB 2.6 oder höher unterstützt. Ältere Versionen werfen einen "command not supported"-Fehler. Indexspezifikationen sind unter createIndexes definiert.

deleteMany​

Löscht mehrere Dokumente in MongoDB.

deleteOne​

Löscht ein Dokument in MongoDB.

distinct​

Der distinct-Befehl liefert eine Liste eindeutiger Werte für den angegebenen Schlüssel in einer Collection.

dropCollectionIndex​

Entfernt einen Index aus dieser Collection.

dropCollectionIndexes​

Entfernt alle Indizes aus der Collection.

findOneAndDelete​

Findet ein Dokument und löscht es in einer atomaren Operation, benötigt für die Dauer der Operation eine Schreibsperre.

findOneAndReplace​

Findet ein Dokument und ersetzt es in einer atomaren Operation, benötigt für die Dauer der Operation eine Schreibsperre.

findOneAndUpdate​

Findet ein Dokument und aktualisiert es in einer atomaren Operation, benötigt für die Dauer der Operation eine Schreibsperre.

geoHaystackSearch​

Führt eine Geo-Suche mit einem geoHaystack-Index in einer Collection durch.

geoNear​

Führt den geoNear-Befehl aus, um Elemente in der Collection zu suchen.

group​

Führt einen Gruppenbefehl über eine Collection aus.

collectionIndexes​

Ruft alle Indizes der Collection ab.

collectionIndexExists​

Ermittelt, ob ein Index in der Collection existiert.

collectionIndexInformation​

Ruft die Indexinformationen dieser Collection ab.

initializeOrderedBulkOp​

Initiiert eine geordnete Bulk-Schreiboperation: Operationen werden seriell in ihrer Hinzufügungsreihenfolge ausgeführt, wobei bei jedem Typwechsel eine neue Operation erstellt wird.

initializeUnorderedBulkOp​

Initiiert eine ungeordnete Batch-Schreiboperation. Alle Operationen werden in Einfüge-/Aktualisierungs-/Löschbefehle gepuffert und ungeordnet ausgeführt.

insertMany​

Fügt ein Array von Dokumenten in MongoDB ein.

insertOne​

Fügt ein einzelnes Dokument in MongoDB ein.

isCapped​

Gibt zurück, ob es sich um eine capped Collection handelt.

listCollectionIndexes​

Ruft die Liste aller Indexinformationen der Collection ab.

parallelCollectionScan​

Gibt N parallele Cursor für eine Collection zurück, die paralleles Lesen der gesamten Collection ermöglichen. Es gibt keine Reihenfolgegarantien für Ergebnisse.

reIndex​

Indiziert alle Indizes der Collection neu. Warnung: reIndex ist eine blockierende Operation (Indizes werden im Vordergrund neu aufgebaut) und kann bei großen Collections langsam sein.

rename​

Ändert den Namen einer bestehenden Collection.

replaceOne​

Ersetzt ein Dokument in MongoDB.

stats​

Ruft alle Collection-Statistiken ab.

updateMany​

Aktualisiert mehrere Dokumente in der Collection basierend auf dem Filter.

updateOne​

Aktualisiert ein einzelnes Dokument in der Collection basierend auf dem Filter.