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. Gran parte delle funzionalità di TypeORM sono specifiche per RDBMS, questa pagina contiene tutta la documentazione sulle funzionalità specifiche per MongoDB.

Installazione​

npm install mongodb

Opzioni Data Source​

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

  • host - Host del database.

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

  • username - Nome utente del database (sostituto di auth.user).

  • password - Password del database (sostituto di auth.password).

  • database - Nome del database.

  • poolSize - Imposta la dimensione massima del pool per ogni connessione a server o proxy.

  • tls - Utilizza una connessione TLS/SSL (richiede un server mongod con supporto SSL, versione 2.4 o superiore). Default: false.

  • tlsAllowInvalidCertificates - Specifica se il driver genera un errore quando il certificato TLS del server è invalido. Default: 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.

  • keepAlive - Numero di millisecondi da attendere prima di avviare keepAlive sul socket TCP. Default: 30000.

  • connectTimeoutMS - Impostazione timeout di connessione TCP. Default: 30000.

  • socketTimeoutMS - Impostazione timeout del socket TCP. Default: 360000.

  • replicaSet - Nome del replica set a cui connettersi.

  • authSource - Se l'autenticazione del database dipende da un altro nome di database.

  • writeConcern - Livello di garanzia di scrittura (write concern).

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

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

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

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

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

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

  • promoteValues - Promuove valori BSON a tipi nativi dove possibile, impostare su false per ricevere solo tipi wrapper. Default: true.

  • readPreference - Preferenza di lettura:

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

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

  • readConcern - Specifica un read concern per la collezione (supportato solo in MongoDB 3.2 o superiore).

  • maxStalenessSeconds - Specifica un valore maxStalenessSeconds per letture secondarie, minimo 90 secondi.

  • appName - Nome dell'applicazione che ha creato questa istanza MongoClient. MongoDB 3.4 e superiori registrano questo valore nel log del server ad ogni connessione. Viene anche registrato nei log di query lente e collezioni di profilo.

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

  • directConnection - Specifica se forzare l'invio di tutte le operazioni all'host specificato.

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 { Entity, ObjectId, 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 { 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[]
}

Se salvi questa entità:

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)

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

In:

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. Questo metodo è supportato solo in MongoDB 2.6 o superiore. Versioni precedenti genereranno un errore "comando non supportato". 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.

stats​

Ottiene tutte le statistiche della collezione.

updateMany​

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

updateOne​

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