Zum Hauptinhalt springen

Repository-APIs

Inoffizielle Beta-Übersetzung

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

Repository-API​

  • manager - Der von diesem Repository verwendete EntityManager.
const manager = repository.manager
  • metadata - Die EntityMetadata der durch dieses Repository verwalteten Entität.
const metadata = repository.metadata
  • queryRunner - Der vom EntityManager verwendete Query Runner. Wird nur in transaktionalen EntityManager-Instanzen genutzt.
const queryRunner = repository.queryRunner
  • target - Die Ziel-Entitätsklasse, die von diesem Repository verwaltet wird. Wird nur in transaktionalen EntityManager-Instanzen verwendet.
const target = repository.target
  • createQueryBuilder - Erstellt einen Query Builder zum Erstellen von SQL-Abfragen. Mehr zum QueryBuilder.
const users = await repository
    .createQueryBuilder("user")
    .where("user.name = :name", { name: "John" })
    .getMany()
  • hasId - Prüft, ob die Primärspalten-Eigenschaft der gegebenen Entität definiert ist.
if (repository.hasId(user)) {
    // ... do something
}
  • getId - Ruft die Werte der Primärspalten-Eigenschaften 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ärspalten.
const userId = repository.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 = repository.create() // same as const user = new User();
const user = repository.create({
    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()
repository.merge(user, { firstName: "Timber" }, { lastName: "Saw" }) // same as user.firstName = "Timber"; user.lastName = "Saw";

  • preload - Erstellt eine neue Entität aus dem gegebenen einfachen JavaScript-Objekt. Wenn die Entität bereits in der Datenbank existiert, lädt sie diese (und alle damit verbundenen Elemente), ersetzt alle Werte mit den neuen Werten aus dem gegebenen Objekt und gibt die neue Entität zurück. Die neue Entität ist tatsächlich eine aus der Datenbank geladene Entität, bei der alle Eigenschaften durch die des neuen Objekts ersetzt wurden.

    Hinweis: Das gegebene entitätsähnliche Objekt muss eine Entitäts-ID / einen Primärschlüssel enthalten, um die Entität zu finden. Gibt undefined zurück, wenn keine Entität mit der angegebenen ID gefunden wurde.

const partialUser = {
    id: 1,
    firstName: "Rizzrak",
    profile: {
        id: 1,
    },
}
const user = await repository.preload(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. Wenn die Entität bereits in der Datenbank existiert, wird sie aktualisiert. Wenn die Entität nicht in der Datenbank existiert, wird sie eingefügt. Alle gegebenen Entitäten werden in einer einzigen Transaktion gespeichert (bei einer einzelnen Entität ist der Manager nicht transaktional). Unterstützt auch teilweise Aktualisierungen, da undefinierte Eigenschaften übersprungen werden. Gibt die gespeicherte(n) Entität(en) zurück.
await repository.save(user)
await repository.save([category1, category2, category3])
  • remove - Entfernt eine gegebene Entität oder ein Array von Entitäten. Alle gegebenen Entitäten werden in einer einzigen Transaktion entfernt (bei einer einzelnen Entität ist der Manager nicht transaktional). Gibt die entfernte(n) Entität(en) zurück.
await repository.remove(user)
await repository.remove([category1, category2, category3])
  • insert - Fügt eine neue Entität oder ein Array von Entitäten ein.
await repository.insert({
    firstName: "Timber",
    lastName: "Timber",
})

await repository.insert([
    {
        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 repository.update({ age: 18 }, { category: "ADULT" })
// executes UPDATE user SET category = ADULT WHERE age = 18

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

// optionally request RETURNING / OUTPUT values (supported drivers only)
const result = await repository.update(
    1,
    { firstName: "Rizzrak" },
    { returning: ["id", "firstName"] },
)
console.log(result.raw) // [{ id: 1, firstName: "Rizzrak" }]
  • updateAll - Aktualisiert alle Entitäten des Zieltyps (ohne WHERE-Klausel). Setzt Felder aus dem bereitgestellten partiellen Entitätsobjekt.
await repository.updateAll({ category: "ADULT" })
// executes UPDATE user SET category = ADULT

await repository.updateAll(
    { category: "ADULT" },
    { returning: "*" }, // limited to drivers that support returning clauses
)
  • 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 repository.upsert(
    [
        { 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
 *  SET firstName = EXCLUDED.firstName,
 *      updatedDate = CURRENT_TIMESTAMP,
 *      version = version + 1
 **/

Du kannst auch anfordern, dass Werte von einem Upsert zurückgegeben werden (unterstützt von Treibern mit RETURNING / OUTPUT-Unterstützung):

const { raw } = await repository.upsert(
    { externalId: "abc123", firstName: "Rizzrak" },
    {
        conflictPaths: ["externalId"],
        returning: ["externalId", "firstName"],
    },
)
console.log(raw) // [{ externalId: "abc123", firstName: "Rizzrak" }]
await repository.upsert(
    [
        { externalId: "abc123", firstName: "Rizzrak" },
        { externalId: "bca321", firstName: "Karzzir" },
    ],
    {
        conflictPaths: ["externalId"],
        skipUpdateIfNoValuesChanged: true, // supported by postgres, skips update if it would not change row values
        upsertType: "upsert", //  "on-conflict-do-update" | "on-duplicate-key-update" | "upsert" - optionally provide an UpsertType - 'upsert' is currently only supported by CockroachDB
    },
)
/** executes
 *  INSERT INTO user
 *  VALUES
 *      (externalId = abc123, firstName = Rizzrak),
 *      (externalId = cba321, firstName = Karzzir),
 *  ON CONFLICT (externalId) DO UPDATE
 *  SET firstName = EXCLUDED.firstName
 *  WHERE user.firstName IS DISTINCT FROM EXCLUDED.firstName
 **/
await repository.upsert(
    [
        { externalId: "abc123", firstName: "Rizzrak", dateAdded: "2020-01-01" },
        { externalId: "bca321", firstName: "Karzzir", dateAdded: "2022-01-01" },
    ],
    {
        conflictPaths: ["externalId"],
        skipUpdateIfNoValuesChanged: true, // supported by postgres, skips update if it would not change row values
        indexPredicate: "dateAdded > 2020-01-01", // supported by postgres, allows for partial indexes
    },
)
/** executes
 *  INSERT INTO user
 *  VALUES
 *      (externalId = abc123, firstName = Rizzrak, dateAdded = 2020-01-01),
 *      (externalId = cba321, firstName = Karzzir, dateAdded = 2022-01-01),
 *  ON CONFLICT (externalId) WHERE ( dateAdded > 2021-01-01 ) DO UPDATE
 *  SET firstName = EXCLUDED.firstName,
 *  SET dateAdded = EXCLUDED.dateAdded,
 *  WHERE user.firstName IS DISTINCT FROM EXCLUDED.firstName OR user.dateAdded IS DISTINCT FROM EXCLUDED.dateAdded
 **/
  • delete - Löscht Entitäten anhand der Entitäts-ID, IDs oder gegebener Bedingungen:
await repository.delete(1)
await repository.delete([1, 2, 3])
await repository.delete({ firstName: "Timber" })
  • deleteAll - Löscht alle Entitäten des Zieltyps (ohne WHERE-Klausel).
await repository.deleteAll()
// executes DELETE FROM user

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

  • softDelete und restore - Soft-Delete und Wiederherstellen einer Zeile anhand von ID, IDs oder gegebenen Bedingungen:
const repository = dataSource.getRepository(Entity)
// Soft delete an entity
await repository.softDelete(1)
// And you can restore it using restore;
await repository.restore(1)
// Soft delete multiple entities
await repository.softDelete([1, 2, 3])
// Or soft delete by other attribute
await repository.softDelete({ firstName: "Jake" })
  • softRemove und recover - Alternative zu softDelete und restore.
// You can soft-delete them using softRemove
const entities = await repository.find()
const entitiesAfterSoftRemove = await repository.softRemove(entities)

// And You can recover them using recover;
await repository.recover(entitiesAfterSoftRemove)
  • increment - Erhöht eine Spalte um den angegebenen Wert bei Entitäten, die den gegebenen Optionen entsprechen.
await repository.increment({ firstName: "Timber" }, "age", 3)
  • decrement - Verringert eine Spalte um den angegebenen Wert bei Entitäten, die den gegebenen Optionen entsprechen.
await repository.decrement({ firstName: "Timber" }, "age", 3)
  • exists - Prüft, ob eine Entität existiert, die den FindOptions entspricht.
const exists = await repository.exists({
    where: {
        firstName: "Timber",
    },
})
  • existsBy - Prüft, ob eine Entität existiert, die den FindOptionsWhere entspricht.
const exists = await repository.existsBy({ firstName: "Timber" })
  • count - Zählt Entitäten, die den FindOptions entsprechen. Nützlich für Paginierung.
const count = await repository.count({
    where: {
        firstName: "Timber",
    },
})
  • countBy - Zählt Entitäten, die den FindOptionsWhere entsprechen. Nützlich für Paginierung.
const count = await repository.countBy({ firstName: "Timber" })
  • sum - Gibt die Summe eines numerischen Felds für alle Entitäten zurück, die den FindOptionsWhere entsprechen.
const sum = await repository.sum("age", { firstName: "Timber" })
  • average - Gibt den Durchschnittswert eines numerischen Felds für alle Entitäten zurück, die den FindOptionsWhere entsprechen.
const average = await repository.average("age", { firstName: "Timber" })
  • minimum - Gibt den Minimalwert eines numerischen Felds für alle Entitäten zurück, die den FindOptionsWhere entsprechen.
const minimum = await repository.minimum("age", { firstName: "Timber" })
  • maximum - Gibt den Maximalwert eines numerischen Felds für alle Entitäten zurück, die den FindOptionsWhere entsprechen.
const maximum = await repository.maximum("age", { firstName: "Timber" })
  • find - Findet Entitäten, die den gegebenen FindOptions entsprechen.
const timbers = await repository.find({
    where: {
        firstName: "Timber",
    },
})
  • findBy - Findet Entitäten, die den gegebenen FindWhereOptions entsprechen.
const timbers = await repository.findBy({
    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 repository.findAndCount({
    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 repository.findAndCountBy({
    firstName: "Timber",
})
  • findOne - Findet die erste Entität, die den angegebenen FindOptions entspricht.
const timber = await repository.findOne({
    where: {
        firstName: "Timber",
    },
})
  • findOneBy - Findet die erste Entität, die den angegebenen FindOptionsWhere entspricht.
const timber = await repository.findOneBy({ 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 repository.findOneOrFail({
    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 repository.findOneByOrFail({ firstName: "Timber" })
  • query - Führt eine rohe SQL-Abfrage aus.
const rawData = await repository.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 repository.query(
    "SELECT * FROM USERS WHERE name = ? and age = ?",
    ["John", 24],
)

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

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

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

// mssql
const rawData = await repository.query(
    "SELECT * FROM USERS WHERE name = @0 and age = @1",
    ["John", 24],
)
  • clear - Löscht alle Daten aus der angegebenen Tabelle (truncate/drop).
await repository.clear()

Zusätzliche Optionen​

Optionale SaveOptions können als Parameter für save übergeben werden.

  • data - Zusätzliche Daten, die mit der persist-Methode übergeben werden. Diese Daten können dann in Subscribern verwendet werden.

  • listeners: boolean - Gibt an, ob Listener und Subscriber für diese Operation aufgerufen werden. Standardmäßig aktiviert, deaktivierbar durch { listeners: false } in Save/Remove-Optionen.

  • transaction: boolean - Standardmäßig sind Transaktionen aktiviert und alle Abfragen werden darin eingebettet. Deaktivierbar durch { transaction: false } in Persistenz-Optionen.

  • chunk: number - Unterteilt Save-Operationen in Chunks. Beispiel: Bei 100.000 Objekten kann { chunk: 10000 } 10 Gruppen zu 10.000 Objekten bilden. Nützlich bei Treiberbeschränkungen der Parameteranzahl.

  • reload: boolean - Bestimmt, ob die persistierte Entität neu geladen wird. Funktioniert nur bei Datenbanken ohne RETURNING/OUTPUT-Unterstützung. Standardmäßig aktiviert.

Beispiel:

userRepository.save(users, { chunk: 1000 })

Optionale RemoveOptions können als Parameter für remove und delete übergeben werden.

  • data - Zusätzliche Daten, die mit der Remove-Methode übergeben werden. Diese Daten können dann in Subscribern verwendet werden.

  • listeners: boolean - Gibt an, ob Listener und Subscriber für diese Operation aufgerufen werden. Standardmäßig aktiviert, deaktivierbar durch { listeners: false } in Save/Remove-Optionen.

  • transaction: boolean - Standardmäßig sind Transaktionen aktiviert und alle Abfragen werden darin eingebettet. Deaktivierbar durch { transaction: false } in Persistenz-Optionen.

  • chunk: number - Unterteilt Löschoperationen in Chunks. Beispiel: Bei 100.000 Objekten kann { chunk: 10000 } 10 Gruppen zu 10.000 Objekten bilden. Nützlich bei Treiberbeschränkungen der Parameteranzahl.

Beispiel:

userRepository.remove(users, { chunk: 1000 })

TreeRepository-API​

Für die TreeRepository-API siehe die Tree-Entities-Dokumentation.

MongoRepository-API​

Für die MongoRepository-API siehe die MongoDB-Dokumentation.