TypeORM - Query Builder

Il generatore di query viene utilizzato per creare query SQL complesse in modo semplice. Viene inizializzato dal metodo di connessione e dagli oggetti QueryRunner.

Possiamo creare QueryBuilder in tre modi.

Connessione

Considera un semplice esempio di come utilizzare QueryBuilder utilizzando il metodo di connessione.

import {getConnection} from "typeorm"; 

const user = await getConnection() .createQueryBuilder() 
.select("user") 
.from(User, "user") 
.where("user.id = :id", { id: 1 }) .getOne();

Responsabile entità

Creiamo un generatore di query utilizzando il gestore entità come segue:

import {getManager} from "typeorm"; 

const user = await getManager() .createQueryBuilder(User, "user") .where("user.id = :id", { id: 1 })    .getOne();

Repository

Possiamo usare il repository per creare un generatore di query. È descritto di seguito,

import {getRepository} from "typeorm"; 

const user = await getRepository(User) .createQueryBuilder("user") .where("user.id = :id", { id: 1 }) .getOne();

Alias

Gli alias sono gli stessi dell'alias SQL. Creiamo alias per la tabella Studente utilizzando QueryBuilder come descritto di seguito -

import {getConnection} from "typeorm"; 

const user = await getConnection() .createQueryBuilder() 
.select("stud") 
.from(Student, "stud")

Questa query è equivalente a,

select * from students as stud

Parametri

Parametersvengono utilizzati come segnaposto per i valori dinamici nella query. In molti casi, la query per trovare un oggetto entità diverso sarà la stessa tranne i valori. Ad esempio, la query per trovare uno studente diverso è la stessa tranne il fileStudent IDdati. In questo caso, possiamo usare il parametro perStudent ID e quindi modificare il parametro per ottenere i diversi oggetti studente.

Un altro uso importante del parametro è prevenire l'iniezione SQL. È una delle più importanti violazioni della sicurezza nelle moderne applicazioni web. Utilizzando il parametro nella query, possiamo sopravvivere agli attacchi di SQL injection.

Un altro uso importante del parametro è prevenire l'iniezione SQL. È una delle più importanti violazioni della sicurezza nelle moderne applicazioni web. Utilizzando il parametro nella query, possiamo sopravvivere agli attacchi di SQL injection.

Per esempio

"student.id = :id", { id: 1 }

Qui,

: id - nome del parametro.

{id: 1} - valore del parametro

Aggiunta di espressione

Questa sezione spiega come utilizzare le espressioni.

dove

where viene utilizzato per filtrare i record se la condizione viene soddisfatta.

createQueryBuilder("student") .where("student.id = :id", { id: 1 })

Questa query è equivalente a,

select * from students student where student.id=1;

Possiamo anche usare le condizioni AND, OR, NOT, IN all'interno.

avendo

L'espressione semplice è definita di seguito:

createQueryBuilder("student") .having("student.id = :id", { id: 1 })

Questa query è equivalente a,

select * from students student having student.id=1;

ordinato da

orderby viene utilizzato per ordinare i record in base al campo.

createQueryBuilder("student") .orderBy("student.name")

Questa query è equivalente a,

select * from students student order by student.name;

raggruppa per

Viene utilizzato per raggruppare i record in base alla colonna specificata.

createQueryBuilder("student") .groupBy("student.id")

Questa query è equivalente a,

select * from students student group by student.id;

limite

Viene utilizzato per limitare la selezione delle righe. Di seguito, l'esempio mostra come utilizzare il limite nel generatore di query,

createQueryBuilder("student") .limit(5)

Questa query è equivalente a,

select * from students student limit 5;

compensare

L'offset viene utilizzato per specificare quante righe saltare il risultato. È definito di seguito:

createQueryBuilder("student") .offset(5)

Questa query è equivalente a,

select * from students student offset 5;

si unisce

La clausola join viene utilizzata per combinare righe da due o più tabelle, in base a una colonna correlata. Considera le due entità:

Student.ts

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[]; 
}

Project.ts

import {Entity, PrimaryGeneratedColumn, Column, ManyToOne} from "typeorm"; 
import {Student} from "./Student"; 

@Entity() 
export class Project { 

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

Eseguiamo un semplice join sinistro utilizzando la query seguente:

const student = await createQueryBuilder("student") .leftJoinAndSelect("student.projects", "project") 
.where("student.name = :name", { name: "Student1" }) 
.getOne();

Questa query è equivalente a,

SELECT student.*, project.* FROM students student 
   LEFT JOIN projects project ON project.student = student.id 
   WHERE student.name = 'Student1'

Allo stesso modo, possiamo provare anche Inner join.

Partecipa senza selezione

Possiamo unire i dati senza usare select. Proviamo questo esempio usando Inner join come segue:

const student = await createQueryBuilder("student") .innerJoin("student.projects", "project") 
   .where("student.name = :name", { name: "student1" }) 
   .getOne();

La query sopra è equivalente a -

SELECT student.* FROM students student 
   INNER JOIN projects project ON project.student = student.id 
   WHERE student.name = 'Student1';

Impaginazione

Se hai più dati nella tua applicazione, hai bisogno di funzionalità di impaginazione, scorrimento pagina o scorrimento.

Ad esempio, se desideri mostrare i primi cinque progetti degli studenti nella tua domanda,

const students = await getRepository(Student) .createQueryBuilder("student") .leftJoinAndSelect("student.projects", "project") 
   .take(5) 
   .getMany();

sottoquery

Si chiama query all'interno di un'altra query o query annidata. Usiamo sottoquery nelle espressioni FROM, WHERE e JOIN.

Di seguito è mostrato un semplice esempio:

const projects = await connection .createQueryBuilder() .select("project.id", "id")
.addSelect(subQuery => { 
   return subQuery 
      .select("student.name", "name") .from(Student, "student") 
      .limit(1); 
}, "name")
.from(Project, "project") .getMany();

Campo nascosto

Se uno dei campi della colonna è contrassegnato come {select: false}, quella colonna viene considerata come colonna nascosta. Considera l'entità sottostante:

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

@Entity() 
export class Student {

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string; 
   
   @Column({select: false}) 
   address: string; 
}

Qui,

address il campo è contrassegnato come hidden. Possiamo usareaddSelectmetodo per recuperare le informazioni dalla colonna. È definito di seguito,

const student = await connection.getRepository(Student) .createQueryBuilder() .select("student.id", "student")    .addSelect("student.address") .getMany();

getSql ()

Questo metodo viene utilizzato per ottenere la query SQL generata dal generatore di query. È definito di seguito:

const sql = createQueryBuilder("student") .where("student.name = :name", { name: "Student1" })  .orWhere("student.age = :age", { age: 14 }) 
.getSql();