Vai al contenuto principale

MongoDB

Traduzione Beta Non Ufficiale

Questa pagina è stata tradotta da PageTurner AI (beta). Non ufficialmente approvata dal progetto. Hai trovato un errore? Segnala problema →

Supporto MongoDB​

TypeORM offre un supporto base per MongoDB (driver Node.js v7 o successiva).

La maggior parte delle funzionalità di TypeORM è specifica per RDBMS; questa pagina contiene tutte le funzionalità specifiche per MongoDB.

Installazione​

npm install mongodb

Opzioni Data Source​

  • appName - Nome dell'applicazione che ha creato questa istanza di MongoClient. MongoDB registrerà questo valore nel log del server durante ogni connessione. È inoltre presente nei log delle query lente e nelle collezioni di profilo.

  • authMechanism - Imposta il meccanismo di autenticazione che MongoDB utilizzerà per autenticare la connessione.

  • authSource - Specifica il nome del database associato alle credenziali dell'utente.

  • autoEncryption - Abilita opzionalmente la crittografia automatica durante l'uso.

  • checkServerIdentity - Verifica che il certificato cert sia stato emesso per hostname.

  • compressors - Array o stringa delimitata da virgole di compressori per abilitare la compressione di rete nelle comunicazioni tra questo client e un'istanza mongod/mongos.

  • connectTimeoutMS - Tempo in millisecondi per tentare una connessione prima del timeout. Predefinito: 30000.

  • database - Nome del database.

  • directConnection - Permette al driver di forzare una topologia Single con stringhe di connessione contenenti un singolo host.

  • driver - Oggetto driver. Predefinito: require("mongodb").

  • family - Famiglia IP.

  • forceServerObjectId - Forza il server ad assegnare valori _id invece del driver. Default: false.

  • host - Host del database.

  • hostReplicaSet - Replica set dell'host del database.

  • ignoreUndefined - Specifica se il serializzatore BSON deve ignorare campi non definiti. Default: false.

  • localThresholdMS - Dimensione (in millisecondi) della finestra di latenza per selezionare tra più istanze MongoDB idonee.

  • maxStalenessSeconds - Specifica in secondi quanto un secondario può essere obsoleto prima che il client cessi di usarlo per le letture. Minimo 90 secondi.

  • minPoolSize - Numero minimo di connessioni nel pool di connessione.

  • monitorCommands - Abilita il monitoraggio dei comandi per questo client.

  • noDelay - Connessione TCP senza ritardo.

  • password - Password del database.

  • pkFactory - Factory per chiavi primarie per generare chiavi _id personalizzate.

  • poolSize - Numero massimo di connessioni nel pool di connessione. Mappato sull'opzione maxPoolSize del driver MongoDB.

  • port - Porta dell'host del database. La porta predefinita di MongoDB è 27017.

  • promoteBuffers - Promuove valori Binary BSON a buffer Node nativi. Default: false.

  • promoteLongs - Promuove valori Long a number se rientrano nella risoluzione a 53-bit. Default: true.

  • promoteValues - Promuove i valori BSON a tipi nativi dove possibile. Impostare false per ricevere solo tipi wrapper. Predefinito: true.

  • proxyHost - Configura un host proxy Socks5 per creare connessioni TCP.

  • proxyPassword - Configura una password proxy Socks5 quando richiesta l'autenticazione username/password.

  • proxyPort - Configura una porta proxy Socks5 per creare connessioni TCP.

  • proxyUsername - Configura un username proxy Socks5 quando richiesta l'autenticazione username/password.

  • raw - Restituisce i documenti come buffer BSON grezzi. Default: false.

  • readConcern - Specifica un read concern per la collezione.

  • readPreference - Preferenza di lettura:

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

  • readPreferenceTags - Specifica il documento dei tag come elenco di coppie chiave-valore separate da due punti e delimitate da virgole.

  • replicaSet - Specifica il nome del replica set se il mongod ne fa parte.

  • retryWrites - Abilita scritture ripetibili.

  • serializeFunctions - Serializza funzioni su qualsiasi oggetto. Default: false.

  • socketTimeoutMS - Tempo in millisecondi per tentare un invio/ricezione su socket prima del timeout. Predefinito: 360000.

  • tls - Abilita o disabilita TLS/SSL per la connessione. Predefinito: false.

  • tlsAllowInvalidCertificates - Ignora la validazione dei certificati presentati da istanze mongod/mongos. Predefinito: false.

  • tlsCAFile - Specifica il percorso di un file .pem locale che contiene la catena di certificati root dell'Autorità di Certificazione.

  • tlsCertificateKeyFile - Specifica il percorso di un file .pem locale che contiene il certificato TLS/SSL e la chiave del client.

  • tlsCertificateKeyFilePassword - Specifica la password per decifrare il file tlsCertificateKeyFile.

  • url - URL di connessione dove viene stabilita la connessione. Si noti che altre opzioni del data source sovrascriveranno i parametri impostati tramite l'URL.

  • username - Nome utente del database.

  • writeConcern - WriteConcern di MongoDB che descrive il livello di acknowledgement richiesto per le operazioni di scrittura.

Opzioni aggiuntive possono essere inserite nell'oggetto extra e verranno passate direttamente alla libreria client. Maggiori dettagli nella documentazione di mongodb per Opzioni di Connessione.

Definizione di entità e colonne​

La definizione di entità e colonne è quasi identica a quella dei database relazionali. La differenza principale è l'uso di @ObjectIdColumn al posto di @PrimaryColumn o @PrimaryGeneratedColumn.

Esempio di entità semplice:

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

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

    @Column()
    firstName: string

    @Column()
    lastName: string
}

Ed ecco come avviare l'applicazione:

import { DataSource } from "typeorm"

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

Definizione di sottodocumenti (documenti incorporati)​

Poiché MongoDB memorizza oggetti all'interno di altri oggetti (o documenti dentro documenti), puoi fare lo stesso in TypeORM:

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[]
}

Se salvi questa entità:

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)

Nel database verrà salvato il seguente documento:

{
    "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
        }
    ]
}

Utilizzo di MongoEntityManager e MongoRepository​

Puoi utilizzare la maggior parte dei metodi di EntityManager (escluse funzionalità specifiche per RDBMS come query e transaction). Ad esempio:

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

Per MongoDB esiste anche un MongoEntityManager separato che estende EntityManager.

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

Analogamente a come esiste un MongoEntityManager separato, c'è un MongoRepository che estende Repository:

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

Utilizzo di opzioni avanzate in find():

Uguale:

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

Minore di:

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

Metodi disponibili:

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

Non in:

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

O:

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

Interrogazione di sottodocumenti

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

Interrogazione di array di sottodocumenti

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

Sia MongoEntityManager che MongoRepository includono numerosi metodi specifici per MongoDB:

createCursor​

Crea un cursore per interrogazioni che permette di iterare sui risultati da MongoDB.

createEntityCursor​

Crea un cursore per interrogazioni che permette di iterare sui risultati da MongoDB. Restituisce una versione modificata del cursore che trasforma ogni risultato in modelli Entità.

aggregate​

Esegue una pipeline del framework di aggregazione sulla collezione.

bulkWrite​

Esegue un'operazione bulkWrite senza un'API fluida.

count​

Conta i documenti corrispondenti a una query nel database.

countDocuments​

Conta i documenti corrispondenti a una query nel database.

createCollectionIndex​

Crea un indice sul database e sulla collezione.

createCollectionIndexes​

Crea più indici nella collezione. Le specifiche degli indici sono definite in createIndexes.

deleteMany​

Elimina più documenti su MongoDB.

deleteOne​

Elimina un documento su MongoDB.

distinct​

Il comando distinct restituisce un elenco di valori univoci per la chiave specificata in una collezione.

dropCollectionIndex​

Elimina un indice da questa collezione.

dropCollectionIndexes​

Elimina tutti gli indici dalla collezione.

findOneAndDelete​

Trova un documento e lo elimina in un'operazione atomica, richiedendo un lock in scrittura per la durata dell'operazione.

findOneAndReplace​

Trova un documento e lo sostituisce in un'operazione atomica, richiedendo un lock in scrittura per la durata dell'operazione.

findOneAndUpdate​

Trova un documento e lo aggiorna in un'operazione atomica, richiedendo un lock in scrittura per la durata dell'operazione.

geoHaystackSearch​

Esegue una ricerca geografica utilizzando un indice geo haystack su una collezione.

geoNear​

Esegue il comando geoNear per cercare elementi nella collezione.

group​

Esegue un comando group su una collezione.

collectionIndexes​

Recupera tutti gli indici della collezione.

collectionIndexExists​

Verifica se un indice esiste nella collezione.

collectionIndexInformation​

Recupera le informazioni sugli indici di questa collezione.

initializeOrderedBulkOp​

Inizia un'operazione bulk ordinata; le operazioni verranno eseguite in serie secondo l'ordine di aggiunta, creando una nuova operazione per ogni cambio di tipo.

initializeUnorderedBulkOp​

Inizia un'operazione bulk non ordinata. Tutte le operazioni verranno bufferizzate in comandi insert/update/remove eseguiti senza un ordine specifico.

insertMany​

Inserisce un array di documenti in MongoDB.

insertOne​

Inserisce un singolo documento in MongoDB.

isCapped​

Restituisce se la collezione è una capped collection.

listCollectionIndexes​

Ottiene l'elenco di tutte le informazioni sugli indici della collezione.

parallelCollectionScan​

Restituisce N cursori paralleli per una collezione, consentendo la lettura parallela dell'intera collezione. Non ci sono garanzie di ordinamento per i risultati.

reIndex​

Reindicizza tutti gli indici della collezione. Attenzione: reIndex è un'operazione bloccante (gli indici vengono ricostruiti in foreground) e può essere lenta per collezioni di grandi dimensioni.

rename​

Cambia il nome di una collezione esistente.

replaceOne​

Sostituisce un documento in MongoDB.

updateMany​

Aggiorna più documenti nella collezione in base al filtro specificato.

updateOne​

Aggiorna un singolo documento nella collezione in base al filtro specificato.