Vai al contenuto principale

API di EntityManager

Traduzione Beta Non Ufficiale

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

  • dataSource - Il DataSource utilizzato da EntityManager.
const dataSource = manager.dataSource
  • queryRunner - Il query runner utilizzato da EntityManager. Usato solo nelle istanze transazionali di EntityManager.
const queryRunner = manager.queryRunner
  • transaction - Fornisce una transazione in cui più richieste al database verranno eseguite in un'unica transazione. Scopri di più sulle Transazioni.
await manager.transaction(async (manager) => {
    // NOTE: you must perform all database operations using the given manager instance
    // it's a special instance of EntityManager working with this transaction
    // and don't forget to await things here
})
  • query - Esegue una query SQL raw.
const rawData = await manager.query(`SELECT * FROM USERS`)

// You can also use parameters to avoid SQL injection
// The syntax differs between the drivers

// aurora-mysql, better-sqlite3, capacitor, cordova,
// expo, mariadb, mysql, nativescript, react-native,
// sap, sqlite, sqljs
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = ? and age = ?",
    ["John", 24],
)

// aurora-postgres, cockroachdb, postgres
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = $1 and age = $2",
    ["John", 24],
)

// oracle
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = :1 and age = :2",
    ["John", 24],
)

// spanner
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = @param0 and age = @param1",
    ["John", 24],
)

// mssql
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = @0 and age = @1",
    ["John", 24],
)
  • sql - Esegue una query SQL raw utilizzando template literals.
const rawData =
    await manager.sql`SELECT * FROM USERS WHERE name = ${"John"} and age = ${24}`

Scopri la sintassi SQL Tag.

  • createQueryBuilder - Crea un query builder utilizzato per costruire query SQL. Scopri di più sul QueryBuilder.
const users = await manager
    .createQueryBuilder()
    .select()
    .from(User, "user")
    .where("user.name = :name", { name: "John" })
    .getMany()
  • hasId - Verifica se l'entità specificata ha la sua proprietà di colonna primaria definita.
if (manager.hasId(user)) {
    // ... do something
}
  • getId - Ottiene il valore della proprietà della colonna primaria dell'entità specificata. Se l'entità ha chiavi primarie composite, il valore restituito sarà un oggetto con nomi e valori delle colonne primarie.
const userId = manager.getId(user) // userId === 1
  • create - Crea una nuova istanza di User. Accetta opzionalmente un oggetto letterale con proprietà utente che verranno scritte nel nuovo oggetto utente creato.
const user = manager.create(User) // same as const user = new User();
const user = manager.create(User, {
    id: 1,
    firstName: "Timber",
    lastName: "Saw",
}) // same as const user = new User(); user.firstName = "Timber"; user.lastName = "Saw";
  • merge - Combina più entità in una singola entità.
const user = new User()
manager.merge(User, user, { firstName: "Timber" }, { lastName: "Saw" }) // same as user.firstName = "Timber"; user.lastName = "Saw";
  • preload - Crea una nuova entità a partire da un oggetto JavaScript semplice. Se l'entità esiste già nel database, la carica (e tutto ciò che è correlato), sostituisce tutti i valori con quelli nuovi dall'oggetto fornito, e restituisce la nuova entità. La nuova entità viene effettivamente caricata dal database con tutte le proprietà sostituite dal nuovo oggetto.
const partialUser = {
    id: 1,
    firstName: "Rizzrak",
    profile: {
        id: 1,
    },
}
const user = await manager.preload(User, partialUser)
// user will contain all missing data from partialUser with partialUser property values:
// { id: 1, firstName: "Rizzrak", lastName: "Saw", profile: { id: 1, ... } }
  • save - Salva un'entità o un array di entità specificato. Se l'entità esiste già nel database, viene aggiornata. Se l'entità non esiste ancora nel database, viene inserita. Salva tutte le entità specificate in un'unica transazione (nel caso in cui l'entity manager non sia transazionale). Supporta anche l'aggiornamento parziale poiché tutte le proprietà non definite vengono saltate. Per impostare un valore su NULL, è necessario impostare manualmente la proprietà su null.
await manager.save(user)
await manager.save([category1, category2, category3])
  • remove - Rimuove un'entità o un array di entità specificato. Rimuove tutte le entità specificate in un'unica transazione (nel caso in cui l'entity manager non sia transazionale).
await manager.remove(user)
await manager.remove([category1, category2, category3])
  • insert - Inserisce una nuova entità o un array di entità.
await manager.insert(User, {
    firstName: "Timber",
    lastName: "Timber",
})

await manager.insert(User, [
    {
        firstName: "Foo",
        lastName: "Bar",
    },
    {
        firstName: "Rizz",
        lastName: "Rak",
    },
])
  • update - Aggiorna le entità in base all'ID dell'entità, a più ID, a condizioni date o a un array di oggetti di condizioni. Imposta i campi dall'entità parziale fornita.
await manager.update(User, { age: 18 }, { category: "ADULT" })
// executes UPDATE user SET category = ADULT WHERE age = 18

await manager.update(User, 1, { firstName: "Rizzrak" })
// executes UPDATE user SET firstName = Rizzrak WHERE id = 1

// Bulk updates with different conditions for each operation
await manager.update(User, [
    { criteria: { id: 1 }, data: { firstName: "Rizzrak" } },
    { criteria: { id: 2 }, data: { firstName: "Karzzir" } },
    { criteria: { age: 18 }, data: { category: "ADULT" } },
])
// executes three separate UPDATE queries:
// UPDATE user SET firstName = Rizzrak WHERE id = 1
// UPDATE user SET firstName = Karzzir WHERE id = 2
// UPDATE user SET category = ADULT WHERE age = 18

Puoi passare un array di oggetti di condizioni per corrispondere a più set distinti di righe in una singola chiamata (le condizioni vengono combinate con OR):

await manager.update(User, [{ status: "expired" }, { flagged: true }], {
    active: false,
})
// executes UPDATE user SET active = false WHERE status = 'expired' OR flagged = true
  • updateAll - Aggiorna tutte le entità del tipo target (senza clausola WHERE). Imposta i campi dall'entità parziale fornita.
await manager.updateAll(User, { category: "ADULT" })
// executes UPDATE user SET category = ADULT
  • upsert - Inserisce una nuova entità o array di entità a meno che non esistano già, nel qual caso vengono invece aggiornate. Supportato dai driver AuroraDataApi, Cockroach, Mysql, Postgres e Sqlite.

Quando un'operazione upsert risulta in un aggiornamento (a causa di un conflitto), colonne speciali come @UpdateDateColumn e @VersionColumn vengono automaticamente aggiornate ai valori correnti.

Le colonne contrassegnate con update: false o definite come colonne generate calcolate (tramite asExpression/generatedType) non sono mai incluse nell'insieme di aggiornamento durante i conflitti. Se tutte le colonne non in conflitto sono escluse da queste regole (cioè non ci sono colonne aggiornabili), l'upsert si degrada a un'operazione insert-or-ignore e la riga esistente rimane completamente invariata. Su database che supportano i target di conflitto (es. PostgreSQL, CockroachDB), questo è limitato alle colonne di conflitto specificate; sui database della famiglia MySQL, viene usato INSERT IGNORE che si applica a tutti i vincoli univoci.

await manager.upsert(
    User,
    [
        { externalId: "abc123", firstName: "Rizzrak" },
        { externalId: "bca321", firstName: "Karzzir" },
    ],
    ["externalId"],
)
/** executes
 *  INSERT INTO user
 *  VALUES
 *      (externalId = abc123, firstName = Rizzrak),
 *      (externalId = cba321, firstName = Karzzir),
 *  ON CONFLICT (externalId) DO UPDATE firstName = EXCLUDED.firstName
 **/
  • delete - Elimina le entità in base all'ID dell'entità, a più ID, a condizioni date o a un array di oggetti di condizioni.
await manager.delete(User, 1)
await manager.delete(User, [1, 2, 3])
await manager.delete(User, { firstName: "Timber" })

// Bulk deletes with different conditions for each operation
await manager.delete(User, [{ firstName: "Timber" }, { age: 18 }, { id: 42 }])
// executes three separate DELETE queries:
// DELETE FROM user WHERE firstName = Timber
// DELETE FROM user WHERE age = 18
// DELETE FROM user WHERE id = 42

Puoi passare un array di oggetti di condizioni per corrispondere a più set distinti di righe in una singola chiamata (le condizioni vengono combinate con OR). Questo è diverso dal passare un array primitivo, che viene trattato come una lista di ID:

// Primitive array — interpreted as WHERE id IN (1, 2, 3)
await manager.delete(User, [1, 2, 3])

// Object array — each element is a separate condition (OR'd together)
await manager.delete(User, [{ id: 1 }, { email: "old@example.com" }])
// executes DELETE FROM user WHERE id = 1 OR email = 'old@example.com'

Nota: passare un oggetto vuoto {} o [{}] genera un TypeORMError per prevenire eliminazioni accidentali dell'intera tabella.

  • deleteAll - Elimina tutte le entità del tipo target (senza clausola WHERE).
await manager.deleteAll(User)
// executes DELETE FROM user

Vedi anche il metodo clear, che esegue un'operazione TRUNCATE TABLE sul database.

  • increment - Incrementa una colonna di un valore fornito per le entità che corrispondono alle opzioni specificate.
await manager.increment(User, { firstName: "Timber" }, "age", 3)
  • decrement - Decrementa una colonna di un valore fornito per le entità che corrispondono alle opzioni specificate.
await manager.decrement(User, { firstName: "Timber" }, "age", 3)
  • exists - Verifica se esiste almeno un'entità che corrisponde alle FindOptions.
const exists = await manager.exists(User, {
    where: {
        firstName: "Timber",
    },
})
  • existsBy - Verifica se esiste almeno un'entità che corrisponde a FindOptionsWhere.
const exists = await manager.existsBy(User, { firstName: "Timber" })
  • count - Conta le entità che corrispondono a FindOptions. Utile per l'impaginazione.
const count = await manager.count(User, {
    where: {
        firstName: "Timber",
    },
})
  • countBy - Conta le entità che corrispondono a FindOptionsWhere. Utile per l'impaginazione.
const count = await manager.countBy(User, { firstName: "Timber" })
  • find - Trova le entità che corrispondono alle FindOptions specificate.
const timbers = await manager.find(User, {
    where: {
        firstName: "Timber",
    },
})
  • findBy - Trova le entità che corrispondono alle FindWhereOptions specificate.
const timbers = await manager.findBy(User, {
    firstName: "Timber",
})
  • findAndCount - Trova le entità che corrispondono alle FindOptions specificate. Conta inoltre tutte le entità che corrispondono alle condizioni fornite, ignorando le impostazioni di impaginazione (opzioni from e take).
const [timbers, timbersCount] = await manager.findAndCount(User, {
    where: {
        firstName: "Timber",
    },
})
  • findAndCountBy - Trova le entità che corrispondono a FindOptionsWhere specificate. Conta anche tutte le entità che corrispondono alle condizioni date, ignorando le impostazioni di paginazione (opzioni from e take).
const [timbers, timbersCount] = await manager.findAndCountBy(User, {
    firstName: "Timber",
})
  • findOne - Trova la prima entità che corrisponde alle FindOptions specificate.
const timber = await manager.findOne(User, {
    where: {
        firstName: "Timber",
    },
})
  • findOneBy - Trova la prima entità che corrisponde alle FindOptionsWhere specificate.
const timber = await manager.findOneBy(User, { firstName: "Timber" })
  • findOneOrFail - Trova la prima entità che corrisponde a un ID o opzioni di ricerca. Respinge la promise restituita se non viene trovata alcuna corrispondenza.
const timber = await manager.findOneOrFail(User, {
    where: {
        firstName: "Timber",
    },
})
  • findOneByOrFail - Trova la prima entità che corrisponde alle FindOptions specificate. Respinge la promise restituita se non viene trovata alcuna corrispondenza.
const timber = await manager.findOneByOrFail(User, { firstName: "Timber" })
  • clear - Cancella tutti i dati (effettua un TRUNCATE) della tabella specificata. Supporta l'opzione cascade per cancellare anche tutti i dati dalle tabelle con chiavi esterne verso questa tabella (supportata solo da PostgreSQL/CockroachDB e Oracle; altri database genereranno un errore se l'opzione cascade è impostata su true).
await manager.clear(User)

// With cascade option (PostgreSQL/CockroachDB and Oracle only)
await manager.clear(User, { cascade: true })
  • getRepository - Ottiene un Repository per eseguire operazioni su una specifica entità. Scopri di più sui Repository.
const userRepository = manager.getRepository(User)
  • getTreeRepository - Ottiene un TreeRepository per eseguire operazioni su una specifica entità. Scopri di più sui Repository.
const categoryRepository = manager.getTreeRepository(Category)
  • getMongoRepository - Ottiene un MongoRepository per eseguire operazioni su una specifica entità. Scopri di più su MongoDB.
const userRepository = manager.getMongoRepository(User)
  • withRepository - Ottiene un'istanza di repository personalizzato utilizzata in una transazione. Scopri di più sui Repository personalizzati.
const myUserRepository = manager.withRepository(UserRepository)
  • release - Rilascia il query runner di un entity manager. Utilizzato solo quando il query runner è stato creato e gestito manualmente.
await manager.release()