Zum Hauptinhalt springen

EntityManager-API

Inoffizielle Beta-Übersetzung

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

  • dataSource - Die vom EntityManager verwendete DataSource.
const dataSource = manager.dataSource
  • queryRunner - Der vom EntityManager verwendete Query Runner. Wird nur in transaktionalen EntityManager-Instanzen genutzt.
const queryRunner = manager.queryRunner
  • transaction - Stellt eine Transaktion bereit, in der mehrere Datenbankanfragen in einer einzelnen Datenbanktransaktion ausgeführt werden. Mehr dazu unter Transaktionen.
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 - Führt eine rohe SQL-Abfrage aus.
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 - Führt eine rohe SQL-Abfrage mit Template-Literalen aus.
const rawData =
    await manager.sql`SELECT * FROM USERS WHERE name = ${"John"} and age = ${24}`

Mehr zur Verwendung der SQL-Tag-Syntax.

  • createQueryBuilder - Erstellt einen Query Builder zum Erstellen von SQL-Abfragen. Mehr zum QueryBuilder.
const users = await manager
    .createQueryBuilder()
    .select()
    .from(User, "user")
    .where("user.name = :name", { name: "John" })
    .getMany()
  • hasId - Prüft, ob die gegebene Entität ihre Primärschlüssel-Spalteneigenschaft definiert hat.
if (manager.hasId(user)) {
    // ... do something
}
  • getId - Ruft den Primärschlüsselwert der gegebenen Entität ab. Bei Entitäten mit zusammengesetzten Primärschlüsseln ist der Rückgabewert ein Objekt mit Namen und Werten der Primärschlüsselspalten.
const userId = manager.getId(user) // userId === 1
  • create - Erstellt eine neue Instanz von User. Akzeptiert optional ein Objektliteral mit Benutzereigenschaften, die in das neu erstellte Benutzerobjekt geschrieben werden.
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 - Fasst mehrere Entitäten zu einer einzelnen Entität zusammen.
const user = new User()
manager.merge(User, user, { firstName: "Timber" }, { lastName: "Saw" }) // same as user.firstName = "Timber"; user.lastName = "Saw";
  • preload - Erstellt eine neue Entität aus einem Plain-JavaScript-Objekt. Existiert die Entität bereits in der Datenbank, lädt sie sie (mit allen Beziehungen), ersetzt alle Werte durch die neuen aus dem gegebenen Objekt und gibt die neue Entität zurück. Die neue Entität wird tatsächlich aus der Datenbank geladen, wobei alle Eigenschaften durch die des neuen Objekts ersetzt werden.
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 - Speichert eine gegebene Entität oder ein Array von Entitäten. Existiert die Entität bereits in der Datenbank, wird sie aktualisiert. Existiert sie noch nicht, wird sie eingefügt. Alle Entitäten werden in einer Transaktion gespeichert (falls der Entity Manager nicht transaktional ist). Unterstützt partielles Updating, da nicht definierte Eigenschaften übersprungen werden. Um einen Wert auf NULL zu setzen, musst du die Eigenschaft explizit auf null setzen.
await manager.save(user)
await manager.save([category1, category2, category3])
  • remove - Entfernt eine gegebene Entität oder ein Array von Entitäten. Alle Entitäten werden in einer Transaktion entfernt (falls der Entity Manager nicht transaktional ist).
await manager.remove(user)
await manager.remove([category1, category2, category3])
  • insert - Fügt eine neue Entität oder ein Array von Entitäten ein.
await manager.insert(User, {
    firstName: "Timber",
    lastName: "Timber",
})

await manager.insert(User, [
    {
        firstName: "Foo",
        lastName: "Bar",
    },
    {
        firstName: "Rizz",
        lastName: "Rak",
    },
])
  • update - Aktualisiert Entitäten anhand ihrer ID, IDs oder gegebener Bedingungen. Setzt Felder aus dem bereitgestellten partiellen Entitätsobjekt.
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
  • updateAll - Aktualisiert alle Entitäten des Zieltyps (ohne WHERE-Klausel). Setzt Felder aus dem bereitgestellten partiellen Entitätsobjekt.
await manager.updateAll(User, { category: "ADULT" })
// executes UPDATE user SET category = ADULT
  • upsert - Fügt eine neue Entität oder ein Array ein, sofern sie nicht existieren. Existieren sie bereits, werden sie stattdessen aktualisiert. Unterstützt von AuroraDataApi, Cockroach, Mysql, Postgres und Sqlite.

Führt eine Upsert-Operation aufgrund eines Konflikts zu einem Update, werden spezielle Spalten wie @UpdateDateColumn und @VersionColumn automatisch auf ihre aktuellen Werte aktualisiert.

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 - Löscht Entitäten anhand ihrer ID, IDs oder gegebener Bedingungen.
await manager.delete(User, 1)
await manager.delete(User, [1, 2, 3])
await manager.delete(User, { firstName: "Timber" })
  • deleteAll - Löscht alle Entitäten des Zieltyps (ohne WHERE-Klausel).
await manager.deleteAll(User)
// executes DELETE FROM user

Siehe auch die clear-Methode, die stattdessen einen TRUNCATE TABLE-Datenbankvorgang ausführt.

  • increment - Erhöht eine Spalte um den angegebenen Wert bei Entitäten, die den gegebenen Optionen entsprechen.
await manager.increment(User, { firstName: "Timber" }, "age", 3)
  • decrement - Verringert eine Spalte um den angegebenen Wert bei Entitäten, die den gegebenen Optionen entsprechen.
await manager.decrement(User, { firstName: "Timber" }, "age", 3)
  • exists - Prüft, ob eine Entität existiert, die den FindOptions entspricht.
const exists = await manager.exists(User, {
    where: {
        firstName: "Timber",
    },
})
  • existsBy - Prüft, ob eine Entität existiert, die den FindOptionsWhere entspricht.
const exists = await manager.existsBy(User, { firstName: "Timber" })
  • count - Zählt Entitäten, die den FindOptions entsprechen. Nützlich für Paginierung.
const count = await manager.count(User, {
    where: {
        firstName: "Timber",
    },
})
  • countBy - Zählt Entitäten, die den FindOptionsWhere entsprechen. Nützlich für Paginierung.
const count = await manager.countBy(User, { firstName: "Timber" })
  • find - Findet Entitäten, die den gegebenen FindOptions entsprechen.
const timbers = await manager.find(User, {
    where: {
        firstName: "Timber",
    },
})
  • findBy - Findet Entitäten, die den gegebenen FindWhereOptions entsprechen.
const timbers = await manager.findBy(User, {
    firstName: "Timber",
})
  • findAndCount - Findet Entitäten, die den gegebenen FindOptions entsprechen. Zählt zusätzlich alle Entitäten, die den Bedingungen entsprechen, ignoriert aber Paginierungseinstellungen (from und take).
const [timbers, timbersCount] = await manager.findAndCount(User, {
    where: {
        firstName: "Timber",
    },
})
  • findAndCountBy - Findet Entitäten, die den angegebenen FindOptionsWhere entsprechen. Zählt auch alle Entitäten, die den Bedingungen entsprechen, ignoriert dabei jedoch Paginierungseinstellungen (from- und take-Optionen).
const [timbers, timbersCount] = await manager.findAndCountBy(User, {
    firstName: "Timber",
})
  • findOne - Findet die erste Entität, die den angegebenen FindOptions entspricht.
const timber = await manager.findOne(User, {
    where: {
        firstName: "Timber",
    },
})
  • findOneBy - Findet die erste Entität, die den angegebenen FindOptionsWhere entspricht.
const timber = await manager.findOneBy(User, { firstName: "Timber" })
  • findOneOrFail - Findet die erste Entität, die einer ID oder Suchoptionen entspricht. Lehnt das zurückgegebene Promise ab, wenn nichts gefunden wird.
const timber = await manager.findOneOrFail(User, {
    where: {
        firstName: "Timber",
    },
})
  • findOneByOrFail - Findet die erste Entität, die den angegebenen FindOptions entspricht. Lehnt das zurückgegebene Promise ab, wenn nichts gefunden wird.
const timber = await manager.findOneByOrFail(User, { firstName: "Timber" })
  • clear - Löscht alle Daten aus der angegebenen Tabelle (truncate/drop).
await manager.clear(User)
  • getRepository - Holt ein Repository für Operationen an einer spezifischen Entität. Mehr über Repositories.
const userRepository = manager.getRepository(User)
  • getTreeRepository - Holt ein TreeRepository für Operationen an einer spezifischen Entität. Mehr über Repositories.
const categoryRepository = manager.getTreeRepository(Category)
  • getMongoRepository - Holt ein MongoRepository für Operationen an einer spezifischen Entität. Mehr über MongoDB.
const userRepository = manager.getMongoRepository(User)
  • withRepository - Holt eine benutzerdefinierte Repository-Instanz für Transaktionen. Mehr über Custom repositories.
const myUserRepository = manager.withRepository(UserRepository)
  • release - Gibt den Query Runner des Entity Managers frei. Wird nur verwendet, wenn der Query Runner manuell erstellt und verwaltet wurde.
await manager.release()