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 Unterstützung für MongoDB (Node.js-Treiber v7 oder höher).

Der Großteil der TypeORM-Funktionalität ist relationale Datenbank-spezifisch. Diese Seite enthält alle MongoDB-spezifischen Funktionen.

Installation​

npm install mongodb

Datenquellen-Optionen​

  • appName - Der Name der Anwendung, die diese MongoClient-Instanz erstellt hat. MongoDB gibt diesen Wert im Server-Log bei jeder Verbindung aus und zeichnet ihn auch im langsamen Abfrage-Log sowie in Profil-Collections auf.

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

  • authSource - Gibt den Datenbanknamen an, der mit den Benutzeranmeldeinformationen verknüpft ist.

  • autoEncryption - Optional die In-Use-Verschlüsselung aktivieren.

  • checkServerIdentity - Überprüft, ob das Zertifikat cert für hostname ausgestellt wurde.

  • compressors - Ein Array oder kommagetrennte Zeichenkette von Kompressoren zur Aktivierung der Netzwerkkomprimierung für die Kommunikation zwischen diesem Client und einer mongod/mongos-Instanz.

  • connectTimeoutMS - Zeit in Millisekunden für Verbindungsversuche vor einem Timeout. Standard: 30000.

  • database - Datenbankname.

  • directConnection - Erlaubt dem Treiber, eine Single-Topologie mit einer Verbindungszeichenfolge mit einem Host zu erzwingen.

  • driver - Das Treiberobjekt. Standardmäßig require("mongodb").

  • family - IP-Familie.

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

  • host - Datenbank-Host.

  • hostReplicaSet - Datenbank-Host-Replikatset.

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

  • localThresholdMS - Größe des Latenzfensters in Millisekunden für die Auswahl zwischen mehreren geeigneten MongoDB-Instanzen.

  • maxStalenessSeconds - Gibt in Sekunden an, wie veraltet ein Secondary sein darf, bevor der Client es nicht mehr für Lesevorgänge verwendet. Minimum: 90 Sekunden.

  • minPoolSize - Minimale Anzahl von Verbindungen im Verbindungspool.

  • monitorCommands - Aktiviert die Befehlsüberwachung für diesen Client.

  • noDelay - TCP-Verbindung ohne Verzögerung.

  • password - Datenbank-Passwort.

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

  • poolSize - Maximale Anzahl von Verbindungen im Verbindungspool. Entspricht der maxPoolSize-Option des MongoDB-Treibers.

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

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

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

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

  • proxyHost - Konfiguriert einen Socks5-Proxy-Host für die Erstellung von TCP-Verbindungen.

  • proxyPassword - Konfiguriert ein Socks5-Proxy-Passwort für Authentifizierung.

  • proxyPort - Konfiguriert einen Socks5-Proxy-Port für die Erstellung von TCP-Verbindungen.

  • proxyUsername - Konfiguriert einen Socks5-Proxy-Benutzernamen für Authentifizierung.

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

  • readConcern - Gibt ein Read Concern für die Collection an.

  • readPreference - Die bevorzugte Lesepräferenz:

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

  • readPreferenceTags - Gibt das Tags-Dokument als kommagetrennte Liste von Doppelpunkt-getrennten Schlüssel-Wert-Paaren an.

  • replicaSet - Gibt den Namen des Replikatsets an, wenn der mongod Mitglied eines Replikatsets ist.

  • retryWrites - Wiederholbare Schreibvorgänge aktivieren.

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

  • socketTimeoutMS - Zeit in Millisekunden für Sende-/Empfangsversuche über einen Socket vor Timeout. Standard: 360000.

  • tls - Aktiviert oder deaktiviert TLS/SSL für die Verbindung. Standard: false.

  • tlsAllowInvalidCertificates - Umgeht die Validierung der von mongod/mongos vorgelegten Zertifikate. 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.

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

  • username - Datenbank-Benutzername.

  • writeConcern - Ein MongoDB WriteConcern, der die Art der Bestätigung für Schreibvorgänge beschreibt.

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 { ObjectId } from "mongodb"
import { Entity, 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 { ObjectId } from "mongodb"
import { Entity, ObjectIdColumn, Column } from "typeorm"

export class Profile {
    @Column()
    about: string

    @Column()
    education: string

    @Column()
    career: string
}
import { ObjectId } from "mongodb"
import { Entity, 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:

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),
]

await myDataSource.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 },
    },
})

Enthaltene Methoden:

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. Die Index-Spezifikationen 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.

updateMany​

Aktualisiert mehrere Dokumente in der Collection basierend auf dem Filter.

updateOne​

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