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();