TypeORM - Relaciones

Las relaciones se utilizan para referir la relación entre la tabla en la base de datos. En general, existe una relación entre dos tablas cuando una de ellas tiene una clave externa que hace referencia a la clave principal de la otra tabla. Esta característica hace que la base de datos relacional sea más poderosa y almacene información de manera eficiente.

TypeORM permite que las entidades se relacionen entre sí y posteriormente tablas de base de datos. En general, la relación se puede clasificar en cuatro categorías más amplias. Son los siguientes,

one-to-one- Un objeto de la entidad dada se relaciona con un solo objeto de la entidad objetivo y viceversa. Por ejemplo, un país tendrá solo una ciudad capital y, de manera similar, una ciudad será la capital de un solo país.

many-to-one- El objeto múltiple de la entidad dada se relaciona con un objeto de la entidad objetivo. Por ejemplo, la ciudad se incluye en un solo país, pero el país puede tener varias ciudades.

one-to-many - Igual que muchos a uno, excepto que la relación se invierte.

many-to-many- El objeto múltiple de la entidad dada se relaciona con el objeto múltiple de la entidad objetivo. Por ejemplo, un artículo puede estar etiquetado en varios temas como lenguaje de programación, finanzas, etc. y, al mismo tiempo, una etiqueta en particular también puede tener varios artículos.

TypeORM también ofrece opciones para mejorar la relación de las entidades. Son los siguientes:

• eager - El objeto de entidad de origen también carga los objetos de entidad de destino.
• cascade - El objeto de la entidad de destino se inserta o actualiza mientras se inserta o actualiza el objeto de la entidad de origen.
• onDelete - Los objetos de la entidad de destino también se eliminan, mientras que el objeto de la entidad de origen se elimina.
• primary - Se usa para especificar que la columna de relación es clave primaria o no.
• nullable - Se usa para especificar que la columna de relación es anulable o no.

Repasemos en detalle diferentes tipos de mapeo de relaciones.

Doce y cincuenta y nueve de la noche

Como aprendimos anteriormente, se refiere a la instancia de un campo de tabla que contiene la instancia de otro campo de tabla y viceversa. Creemos unDetails mesa -

Detalles.ts

import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity() 
export class Details {
   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   gender: string; 
   
   @Column() 
   country: string; 
}

Creemos un Cliente de otra entidad de la siguiente manera:

Customer.ts

import {Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn} from "typeorm"; 

import {Details} from "./Details"; 

@Entity() 
export class Customer { 

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string; 
   
   @OneToOne(type => Details) @JoinColumn() 
   details: Details;
}

Aquí,

Hemos agregado mapeo OneToOne a Details mesa. @JoinColumn() contener un "ID de relación" y una clave externa para Customermesa. Podemos guardar la relación enindex.ts como sigue -

const details = new Details(); details.gender = "female"; details.country = "india" await connection.manager.save(details);

const customer = new Customer(); customer.name = 'customer1'; customer.details = Details; await connection.manager.save(Customer);

Uno a varios y varios a uno

Como aprendimos anteriormente, se refiere a la instancia del primer campo de la tabla que contiene las múltiples instancias del segundo campo de la tabla llamado One-to-Many mapeo y múltiples instancias de la primera tabla contiene solo una instancia de la segunda tabla llamada Many-to-One cartografía.

Considere un ejemplo de Student y project entidades, mientras que el estudiante puede trabajar en más de un proyecto, pero cada proyecto es manejado por un solo estudiante.

Vamos a crear un Project entidad de la siguiente manera:

Proyecto

import {Entity, PrimaryGeneratedColumn, Column, ManyToOne} from "typeorm"; import {Student} from "./Student"; 
@Entity() 
export class Project {  

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   projects: string; 
   
   @ManyToOne(type => Student, student => student.projects) student: Student; 
}

Ahora creamos Student entidad como a continuación -

import {Entity, PrimaryGeneratedColumn, Column, OneToMany} from "typeorm"; import {Project} from "./Project"; 

@Entity() 
export class User {  
   
   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string; 
   
   @OneToMany(type => Project, project => project.student) projects: Project[];  
}

Aquí,

@OneToMany propiedad asignada Project y @ManyToOne propiedad asignada a Student. Sin embargo,@OneToMany no puede existir sin @ManyToOne y @ManyToOne La propiedad contiene "id de relación" y clave externa.

Podemos guardar la conexión en index.ts como sigue -

const proj1 = new Project(); proj1.projects = "database management"; await connection.manager.save(proj1); 

const proj2 = new Project(); proj2.projects = "web application"; await connection.manager.save(proj2); 

const stud = new Student(); stud.name = "Student1"; stud.projects = [proj1, proj2]; await connection.manager.save(stud);

Muchos a muchos

Como aprendimos anteriormente, se refiere a varios registros en una tabla que están relacionados con múltiples registros en otra tabla. Considere un ejemplo, un estudiante universitario puede estar inscrito en varias clases a la vez, lo que significa que el estudiante puede tener cuatro o cinco clases por semestre y una clase puede tener muchos estudiantes.

Podemos simplemente concluir, un estudiante tiene muchas clases y una clase tiene muchos estudiantes. Creemos una entidad paraClasses como sigue -

import {Entity, PrimaryGeneratedColumn, Column} from "typeorm"; 

@Entity() 
export class Classes { 

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string; 
}

Ahora creamos Student entidad como a continuación -

import {Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable} from "typeorm"; 
import {Classes} from "./Classes";

@Entity() 
export class Student { 

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string;

   @Column() 
   subjects: string; 
   
   @ManyToMany(type => Classes) @JoinTable() 
   classes: Classes[];
}