La récupération en spécifiant uniquement une colonne spécifique dans la clause SELECT est appelée projection, mais lorsqu'il n'est pas pratique de récupérer toutes les colonnes (il y a trop de colonnes, il y a de grandes colonnes telles que les LOB). C'est une méthode pratique.
Cette fois, je vais expliquer comment exprimer la projection avec l'API Criteria de Doma.
Il existe deux façons de réaliser une projection avec l'API Criteria.
La version de Doma utilisée ici est la 2.43.0.
Pour un aperçu de Doma et de l'API Criteria, lisez les autres articles dans Introduction à Doma.
Je vais l'expliquer avec un code simplifié. Voir le projet ci-dessous pour l'exemple de code complet.
La base de données contient une table d'employés qui représente les employés.
schema.sql
create table employee (
id integer not null primary key,
name varchar(255) not null,
age integer not null,
salary integer,
job_type varchar(20),
hiredate timestamp,
department_id integer,
version integer not null,
insertTimestamp timestamp,
updateTimestamp timestamp);
Préparez la classe Employé correspondant à la table Employé.
Employee.java
@Entity(metamodel = @Metamodel)
public class Employee {
@Id
Integer id;
String name;
Age age;
Salary salary;
@Column(name = "JOB_TYPE")
JobType jobType;
LocalDate hiredate;
@Column(name = "DEPARTMENT_ID")
Integer departmentId;
@Version
@Column(name = "VERSION")
Integer version;
LocalDateTime insertTimestamp;
LocalDateTime updateTimestamp;
// getter, setter
}
Préparez un DTO (ValueObject) qui contient le résultat projeté.
NameAndSalaryDto.java
public class NameAndSalaryDto {
private final String name;
private final Salary salary;
public NameAndSalaryDto(String name, Salary salary) {
this.name = name;
this.salary = salary;
}
// getter
}
Nous préparerons ʻEmployeeRepository` et ajouterons quelques méthodes à cette classe pour montrer un exemple.
EmployeeRepository.java
public class EmployeeRepository {
private final Entityql entityql;
private final NativeSql nativeSql;
public EmployeeRepository(Config config) {
this.entityql = new Entityql(config);
this.nativeSql = new NativeSql(config);
}
}
C'est une méthode très pratique dans le sens où vous pouvez réutiliser des structures de données existantes.
Vous pouvez utiliser la méthode selectTo pour définir la valeur projetée sur une propriété spécifique de l'entité (les autres propriétés sont définies sur des valeurs nulles ou initiales).
public List<Employee> selectNameAndSalaryAsEntityList() {
Employee_ e = new Employee_();
return entityql.from(e).selectTo(e, e.name, e.salary).fetch();
}
Le SQL émis est le suivant.
select t0_.id, t0_.name, t0_.salary from Employee t0_
Les deux colonnes, nom et salaire, sont le SQL spécifié dans la clause SELECT. Il contient une clé primaire non spécifiée, qui est par conception et est utilisée pour garantir l'unicité de l'entité dans l'ensemble de résultats.
Doma fournit des classes dans le package ʻorg.seasar.doma.jdbc.criteria.tuple qui représentent des combinaisons de valeurs telles que Tuple2, Tuple3, ..., Tuple9`.
Le nombre à la fin du nom de la classe indique le nombre de valeurs que la classe peut gérer.
Voici un exemple de projection de deux colonnes à l'aide de la classe Tuple2.
public List<Tuple2<String, Salary>> selectNameAndSalary() {
Employee_ e = new Employee_();
return nativeSql.from(e).select(e.name, e.salary).fetch();
}
Notez que nous utilisons nativeSql au lieu de ʻentityql. Si vous n'avez pas besoin de gérer des entités avec des identifiants individuels (comme obtenir des résultats sans clé primaire ou utiliser des fonctions d'agrégation), nativeSql` est un bon choix.
Le SQL émis est le suivant.
select t0_.name, t0_.salary from Employee t0_
Seules deux colonnes, nom et salaire, sont le SQL spécifié dans la clause SELECT.
C'est à vous comment utiliser la classe Tuple2-9 dans quelle couche, mais c'est une belle conception de l'utiliser comme structure de données temporaire jusqu'à ce qu'elle soit convertie en DTO (ou ValueObject) de l'application comme indiqué ci-dessous. pense.
public List<NameAndSalaryDto> selectNameAndSalaryAsNameAndSalaryDtoList() {
Employee_ e = new Employee_();
return nativeSql.from(e).select(e.name, e.salary).stream()
.map(tuple -> new NameAndSalaryDto(tuple.getItem1(), tuple.getItem2()))
.collect(Collectors.toList());
}
Si vous spécifiez 10 colonnes ou plus et que vous les recevez, vous pouvez l'exprimer avec l'interface ʻorg.seasar.doma.jdbc.criteria.tuple.Row`, mais si vous avez un grand nombre de colonnes, utilisez une classe d'entité en lecture seule. Ce sera plus facile à comprendre si vous le créez.
J'ai expliqué comment représenter une projection avec l'API Criteria.
S'il y a quelque chose comme la classe Tuple dans la norme Java, j'aimerais l'utiliser, mais c'est ennuyeux qu'elle n'existe pas réellement.
De plus, la classe Tuple2-9 de Doma est également consciente qu'elle sera utilisée dans Kotlin, elle correspond donc à la déclaration de déstructuration. Par conséquent, Kotlin peut le gérer comme suit.
val (number, string) = Tuple2(1, "a")
Recommended Posts