Saltar al contenido principal

API de EntityManager

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

  • dataSource - El DataSource utilizado por EntityManager.
const dataSource = manager.dataSource
  • queryRunner - El ejecutor de consultas utilizado por EntityManager. Se usa únicamente en instancias transaccionales de EntityManager.
const queryRunner = manager.queryRunner
  • transaction - Proporciona una transacción donde múltiples solicitudes a la base de datos se ejecutarán en una única transacción. Más información en Transacciones.
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 - Ejecuta una consulta SQL en bruto.
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 - Ejecuta una consulta SQL en bruto utilizando literales de plantilla.
const rawData =
    await manager.sql`SELECT * FROM USERS WHERE name = ${"John"} and age = ${24}`

Más información sobre el uso de la sintaxis de SQL Tag.

  • createQueryBuilder - Crea un constructor de consultas para construir consultas SQL. Más información sobre QueryBuilder.
const users = await manager
    .createQueryBuilder()
    .select()
    .from(User, "user")
    .where("user.name = :name", { name: "John" })
    .getMany()
  • hasId - Verifica si la entidad dada tiene definida su propiedad de columna primaria.
if (manager.hasId(user)) {
    // ... do something
}
  • getId - Obtiene el valor de la propiedad de columna primaria de la entidad dada. Si la entidad tiene claves primarias compuestas, el valor devuelto será un objeto con los nombres y valores de las columnas primarias.
const userId = manager.getId(user) // userId === 1
  • create - Crea una nueva instancia de User. Opcionalmente acepta un objeto literal con propiedades de usuario que se escribirán en el nuevo objeto de usuario creado.
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 - Fusiona múltiples entidades en una sola entidad.
const user = new User()
manager.merge(User, user, { firstName: "Timber" }, { lastName: "Saw" }) // same as user.firstName = "Timber"; user.lastName = "Saw";
  • preload - Crea una nueva entidad a partir del objeto JavaScript plano dado. Si la entidad ya existe en la base de datos, la carga (y todo lo relacionado con ella), reemplaza todos los valores con los nuevos del objeto dado, y devuelve la nueva entidad. La nueva entidad se carga realmente desde la entidad de base de datos con todas las propiedades reemplazadas por las del nuevo objeto.
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 - Guarda una entidad o un arreglo de entidades. Si la entidad ya existe en la base de datos, se actualiza. Si la entidad aún no existe en la base de datos, se inserta. Guarda todas las entidades dadas en una única transacción (cuando el entity manager no es transaccional). También admite actualizaciones parciales ya que todas las propiedades indefinidas se omiten. Para establecer un valor como NULL, debes configurar manualmente la propiedad igual a null.
await manager.save(user)
await manager.save([category1, category2, category3])
  • remove - Elimina una entidad o un arreglo de entidades. Elimina todas las entidades dadas en una única transacción (cuando el entity manager no es transaccional).
await manager.remove(user)
await manager.remove([category1, category2, category3])
  • insert - Inserta una nueva entidad o un arreglo de entidades.
await manager.insert(User, {
    firstName: "Timber",
    lastName: "Timber",
})

await manager.insert(User, [
    {
        firstName: "Foo",
        lastName: "Bar",
    },
    {
        firstName: "Rizz",
        lastName: "Rak",
    },
])
  • update - Actualiza entidades por su id, ids o condiciones dadas. Establece campos desde una entidad parcial proporcionada.
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 - Actualiza todas las entidades del tipo objetivo (sin cláusula WHERE). Establece campos desde una entidad parcial proporcionada.
await manager.updateAll(User, { category: "ADULT" })
// executes UPDATE user SET category = ADULT
  • upsert - Inserta una nueva entidad o arreglo de entidades a menos que ya existan, en cuyo caso se actualizan. Compatible con AuroraDataApi, Cockroach, Mysql, Postgres y Sqlite.

Cuando una operación upsert resulta en actualización (debido a conflicto), columnas especiales como @UpdateDateColumn y @VersionColumn se actualizan automáticamente a sus valores actuales.

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 entidades por su id, ids o condiciones dadas.
await manager.delete(User, 1)
await manager.delete(User, [1, 2, 3])
await manager.delete(User, { firstName: "Timber" })
  • deleteAll - Elimina todas las entidades del tipo objetivo (sin cláusula WHERE).
await manager.deleteAll(User)
// executes DELETE FROM user

Consulta también el método clear, que realiza una operación TRUNCATE TABLE en la base de datos.

  • increment - Incrementa una columna en el valor proporcionado para entidades que coinciden con las opciones dadas.
await manager.increment(User, { firstName: "Timber" }, "age", 3)
  • decrement - Decrementa una columna en el valor proporcionado para entidades que coinciden con las opciones dadas.
await manager.decrement(User, { firstName: "Timber" }, "age", 3)
  • exists - Verifica si existe alguna entidad que coincida con FindOptions.
const exists = await manager.exists(User, {
    where: {
        firstName: "Timber",
    },
})
  • existsBy - Verifica si existe alguna entidad que coincida con FindOptionsWhere.
const exists = await manager.existsBy(User, { firstName: "Timber" })
  • count - Cuenta las entidades que coinciden con FindOptions. Útil para paginación.
const count = await manager.count(User, {
    where: {
        firstName: "Timber",
    },
})
  • countBy - Cuenta las entidades que coinciden con FindOptionsWhere. Útil para paginación.
const count = await manager.countBy(User, { firstName: "Timber" })
  • find - Busca entidades que coincidan con FindOptions.
const timbers = await manager.find(User, {
    where: {
        firstName: "Timber",
    },
})
  • findBy - Busca entidades que coincidan con FindWhereOptions.
const timbers = await manager.findBy(User, {
    firstName: "Timber",
})
  • findAndCount - Busca entidades que coincidan con FindOptions. También cuenta todas las entidades que coinciden con las condiciones dadas, ignorando la configuración de paginación (opciones from y take).
const [timbers, timbersCount] = await manager.findAndCount(User, {
    where: {
        firstName: "Timber",
    },
})
  • findAndCountBy - Encuentra entidades que coinciden con las opciones FindOptionsWhere. También cuenta todas las entidades que cumplen las condiciones dadas, ignorando la paginación (opciones from y take).
const [timbers, timbersCount] = await manager.findAndCountBy(User, {
    firstName: "Timber",
})
  • findOne - Encuentra la primera entidad que coincide con las opciones FindOptions.
const timber = await manager.findOne(User, {
    where: {
        firstName: "Timber",
    },
})
  • findOneBy - Encuentra la primera entidad que coincide con las opciones FindOptionsWhere.
const timber = await manager.findOneBy(User, { firstName: "Timber" })
  • findOneOrFail - Encuentra la primera entidad que coincide con algún ID u opciones de búsqueda. Rechaza la promesa devuelta si no se encuentra ninguna coincidencia.
const timber = await manager.findOneOrFail(User, {
    where: {
        firstName: "Timber",
    },
})
  • findOneByOrFail - Encuentra la primera entidad que coincide con las opciones FindOptions. Rechaza la promesa devuelta si no se encuentra ninguna coincidencia.
const timber = await manager.findOneByOrFail(User, { firstName: "Timber" })
  • clear - Limpia todos los datos de la tabla especificada (la trunca o elimina).
await manager.clear(User)
  • getRepository - Obtiene un Repository para operar sobre una entidad específica. Más información sobre Repositorios.
const userRepository = manager.getRepository(User)
  • getTreeRepository - Obtiene un TreeRepository para operar sobre una entidad con estructura arbórea. Más información sobre Repositorios.
const categoryRepository = manager.getTreeRepository(Category)
  • getMongoRepository - Obtiene un MongoRepository para operar sobre una entidad MongoDB. Más información sobre MongoDB.
const userRepository = manager.getMongoRepository(User)
  • withRepository - Obtiene una instancia de repositorio personalizado usado en transacciones. Más información sobre Repositorios personalizados.
const myUserRepository = manager.withRepository(UserRepository)
  • release - Libera el query runner asociado al EntityManager. Se usa solo cuando el query runner fue creado y gestionado manualmente.
await manager.release()