TypeORM - Entità

Un'entità è una raccolta di campi e operazioni di database associate. Viene utilizzato per mappare la tabella del database ei suoi campi con le entità e i suoi attributi. Questo capitolo spiega in dettaglio le entità TypeORM.

introduzione

Creiamo una semplice classe Entity nel nostro codice. Spostati nella posizione radice del progetto e vai nella cartella src e spostati nella cartella entità. Ora, crea un file TypeScript, Student.ts e inserisci il codice sottostante -

Student.ts

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

@Entity() 
export class Student {   

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   Name: string; 
   
   @Column() 
   age: number; 
}

Qui,

Entity() La classe decorator viene utilizzata per rappresentare che il file Student class è un'entità.
PrimaryGeneratedColumn() La classe decorator viene utilizzata per rappresentare che la colonna id è la colonna chiave primaria di Student entità.
Column() La classe decorator viene utilizzata per rappresentare altre colonne come Name e Age del Student entità.

Ora, classe Entity Studentè creato. TypeORM genererà automaticamente una tabella corrispondente al fileStudent entità nel nostro database e verrà denominata come student. Ora passa asrc/index.ts file e aggiungi il seguente codice -

index.ts

import "reflect-metadata"; 
import {createConnection} from "typeorm";
import {Student} from "./entity/Student"; //import Student entity

createConnection().then(async connection => { 

   console.log("Inserting a new record into the student database..."); 
   
   //create student object const stud = new Student(); 
   
   //Assign student name and age here stud.Name = "student1"; 
   stud.age = 12; 
   
    //save student object in connection await connection.manager.save(stud); console.log("Saved a new user with id: " + stud.id);
    
    console.log("Loading users from the database...");

    //Display student saved records const students = await connection.manager.find(Student); console.log("Loaded users: ", students);

    console.log("Here you can setup and run express/koa/any other framework.");
}).catch(error => console.log(error));

Qui,

La riga 1-3 importa le classi rilevanti, createConnection e Student
La riga 5 crea una nuova connessione al database utilizzando createConnection e se viene stabilita la connessione, esegue il codice all'interno del file then bloccare.
Riga 10 crea un nuovo oggetto Studente, perno.
La riga 13-14 imposta gli attributi del nostro oggetto perno appena creato.
La riga 17 salva l'entità nel database utilizzando il metodo di salvataggio disponibile in connection.manager oggetto.
La riga 23 recupera i dettagli dello studente dal database utilizzando il metodo find disponibile in connection.manager oggetto.

Avvia il server Mysql ed esegui la tua applicazione

Abbiamo creato l'entità Student e creato la connessione in index.ts. Avviamo sia il server MySql che la tua applicazione.

npm start

Questo restituirà il seguente output sullo schermo:

Produzione

Aperto mysql server che segue student tabella viene aggiunta all'interno del database.

Colonne

Come appreso in precedenza, Entity è in realtà una raccolta di attributi. Come oggetto entità fa riferimento alla tabella del database. I suoi attributi / variabili membro fanno riferimento ai campi / colonne della tabella del database corrispondente. TypeORM supporta tutti i tipi di campi di database tramite la classe Column. Impariamo il diverso tipo di colonna supportato da TypeORM in questo capitolo.

@Column() La classe decorator viene utilizzata per rappresentare la colonna e il suo tipo nell'entità.

Ad esempio, l'attributo età dell'entità studente e il tipo di attributo età possono essere definiti come di seguito:

@Column("int") age: integer; // OR @Column({ type: "int" }) age: integer;

Qui,

ageè l'attributo dell'entità. In altre parole, l'età è un campo / colonna nella tabella degli studenti nel database.
int rappresentano il tipo di colonna età nel database.

TypeORM supporta quasi tutti i tipi disponibili nel popolare motore di database. In realtà, TypeORM abilita diversi set di tipi per ogni motore di database. Possiamo utilizzare qualsiasi tipo di database supportato dal nostro motore di database senza alcun problema.

Ad esempio, il tipo supportato da TypeORM per il motore di database postgresql è il seguente:

int, int2, int4, int8, smallint, integer, bigint, decimal, numeric, real, float, float4, float8, double precision, money, character varying,

varchar, character, char, text, citext, hstore, bytea, bit, varbit, bit

varying, timetz, timestamptz, timestamp, timestamp without time zone, timestamp with time zone, date, time, time without time zone, time with time zone, interval, bool, boolean, enum, point, line, lseg, box, path, polygon, circle, cidr, inet, macaddr, tsvector, tsquery, uuid, xml, json, jsonb, int4range, int8range, numrange, tsrange, tstzrange, daterange, geometry, geography, cube

Allo stesso modo, TypeORM supporta un diverso set di tipi di dati per MySQL.

Opzioni colonna

TypeORM fornisce un ampio insieme di opzioni diverse dal tipo per descrivere la colonna. Ad esempio, l'opzione lunghezza si riferisce alla lunghezza del campo del database e può essere specificata come di seguito:

@Column("varchar", { length: 100 })

Alcune delle opzioni di colonna più comuni sono le seguenti:

name - Nome del campo / colonna del database.
length - Lunghezza del campo / colonna del database.
nullable - Specificare se il campo / colonna del database consente null o meno.
default - Valore predefinito del campo / colonna del database.
primary - Specificare se il campo / colonna del database è la chiave primaria della tabella.
unique - Specificare se il campo / colonna del database è univoco
*precision** - Precisione del campo / colonna del database
scale - Scala del campo / colonna del database
comment - Commento o descrizione del campo / colonna del database

@Generated decoratore

TypeORM fornisce un decoratore aggiuntivo, @Generated per generare automaticamente i valori della colonna. Ad esempio, Universally Unique Identifier (UUID) è abbastanza comune da utilizzare nel database per memorizzare un valore univoco in una colonna. Il codice di esempio per generare l'UUID è il seguente:

@Entity() 
export class Student {
 
   @PrimaryColumn() 
   id: number; 
   
   @Column() 
   @Generated("uuid") 
   uuid: string; 
}

Qui,

uuid viene generato automaticamente e memorizzato all'interno del database.

Colonne primarie

Almeno un campo della colonna primaria è obbligatorio per qualsiasi entità nel database. È classificato in diversi tipi di decoratori. Ne discuteremo uno per uno.

@PrimaryColumn()

Il decoratore @PrimaryColumn () viene utilizzato per creare la colonna primaria per qualsiasi tipo di dati. Di seguito è mostrato un semplice esempio,

import {Entity, PrimaryColumn} from "typeorm"; 

@Entity() 
export class Student {        
@PrimaryColumn() 
   id: number; 
}

Qui,

id è un numero intero, che non accetta valori duplicati, ma dobbiamo assegnare valori.

Possiamo assegnare la colonna primaria anche a uno o più campi, se la situazione lo richiede.

Esempio

import {Entity, PrimaryColumn} from "typeorm"; 

@Entity() 
export class Student { 
   
   @PrimaryColumn() 
   id: number; 
   
   @PrimaryColumn() 
   email: string; 
   
   @PrimaryColumn() 
   phone: number; 
}

@PrimaryGeneratedColumn ()

@PrimaryGeneratedColumn()viene utilizzato per specificare la colonna primaria e per generare automaticamente il valore della colonna nel database. È mostrato di seguito -

import {Entity, PrimaryGeneratedColumn} from "typeorm"; 

@Entity() 
export class Student {

   @PrimaryGeneratedColumn() 
   id: number;
}

Qui,

Non è necessario assegnare un valore id; verrà generato automaticamente dal TypeORM nella tabella del database.

@PrimaryGeneratedColumn ("uuid")

@PrimaryGeneratedColumn accetta anche un argomento per specificare il tipo di generatore. Uno degli utilizzi principali è generare un ID univoco basato sull'UUID.

import {Entity, PrimaryGeneratedColumn} from "typeorm";

@Entity() 
export class Student {  
   @PrimaryGeneratedColumn("uuid") id: string; 
}

tipo di colonna array semplice

Il database relazionale avanzato supporta il tipo di dati dell'array. Per supportare il tipo di dati dell'array, TypeORM fornisce un tipo di colonna speciale, * simple-array "per memorizzare i valori dell'array primitivo. Un codice di esempio per utilizzarlo è il seguente:

@Entity() 
export class Student { 
   
   @PrimaryGeneratedColumn() 
   id: number;

   @Column("simple-array") 
   names: string[]; 
}

tipo di colonna simple-json

Molti moderni motori di database supportano il database JSON. Per utilizzare il tipo di dati JSON, TypeORM fornisce un tipo speciale, single-json. Il codice di esempio da utilizzare è il seguente:

@Entity() 
export class Student { 

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column("simple-json")
   info: { firstName: string, middleName: string, lastName: string }; 
}

Questo valore può essere definito in index.ts come,

index.ts

const stud = new Student(); 
stud.info = { firstName: "John", middleName: "peter", lastName: "Michael" };

Colonne speciali

TypeORM supporta le seguenti colonne speciali

@CreateDateColumn - È una colonna speciale per impostare automaticamente la data di inserimento dell'entità.
@UpdateDateColumn - Viene utilizzato per impostare automaticamente l'ora di aggiornamento dell'entità.
@VersionColumn - Imposta automaticamente il numero di versione per l'entità.

Ereditarietà delle entità

L'ereditarietà delle entità viene utilizzata per ridurre la duplicazione delle entità. Considera le entità seguenti:

Result.ts

@Entity() 
export class Result {    

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   title: string; 
   
   @Column() 
   description: string; 
   
   @Column() 
   eligible: string 
}

Grade.ts

Il codice per grade.ts è il seguente:

@Entity() 
export class Grade {

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

Qui,

Le due entità precedenti hanno colonne id, titolo e descrizione. Utilizzando l'ereditarietà delle entità, creiamo una classe di base Dettagli e combiniamo le due entità precedenti come specificato di seguito.

Details.ts

export abstract class Details {

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   title: string; 
   
   @Column() 
   description: string; 
} 
@Entity() 
export class Result extends Details{  

   @Column() 
   eligible: string 
} 
@Entity() 
export class Grade extends Details{   

   @Column() 
   name : string; 
   
   @Column() 
   grading : string; 
}

Ora avvia il tuo server, potresti vedere la risposta di seguito,