Création de requêtes SOQL dans des classes Apex

Objectifs de formation

Une fois cette unité terminée, vous pourrez :

Créer une requête SOQL dans une méthode
Manipuler les données renvoyées par une requête SOQL

Remarque

Vous souhaitez apprendre en français ? Commencez le défi dans un Trailhead Playground en français et utilisez les traductions fournies entre crochets pour naviguer. Copiez et collez uniquement les valeurs en anglais, car les validations de défi reposent sur les données en anglais. Si vous ne réussissez pas le défi dans votre organisation en français, nous vous recommandons (1) de définir le paramètre régional sur les États-Unis, (2) de définir la langue sur l’anglais en suivant les instructions ici, puis (3) de cliquer à nouveau sur le bouton « Vérifier le défi ».

Consultez le badge Trailhead dans votre langue pour découvrir comment profiter de l’expérience Trailhead traduite.

Vidéo de démonstration Trail Together

Vous souhaitez être guidé pas à pas par un expert pendant que vous travaillez sur cette étape ? Regardez cette vidéo qui fait partie de la série Trail Together sur Trailhead Live.

(Ce clip commence à 17 min 32 s, au cas où vous voudriez revenir en arrière et regarder à nouveau le début de l’étape.)

Introduction

Maintenant que vous comprenez les concepts de base d’une requête SOQL, vous pouvez appliquer vos connaissances sur les champs de formule aux requêtes SOQL.

Notre requête est assez simple : SELECT FirstName, LastName FROM Contact

Nous avons maintenant besoin d’un objet dans lequel stocker les données résultantes. Étant donné que les requêtes SOQL renvoient toujours des données sous la forme d’une liste, nous créons une liste Apex. Comme vous l’avez appris dans Bases d’Apex pour les administrateurs, pour déclarer une liste, vous avez besoin de quelques éléments : le mot réservé List, le type de données (entre < >) et un nom pour la nouvelle liste. Pour cette requête, le type de données est Contact et nous nommons la nouvelle liste listOfContacts. Voici à quoi ressemble la déclaration List :

List<Contact> listofContacts

Pour attribuer les résultats de la requête à la nouvelle liste, nous plaçons un opérateur d’attribution, le symbole égal (=), entre la déclaration List et la requête, comme suit :

List<Contact> listOfContacts = [SELECT FirstName, LastName FROM Contact];

Vous remarquerez la syntaxe. La requête est entre crochets [ ] et l’instruction se termine par un point-virgule (;).

Essayons-la dans la Developer Console. Pour les tests, nous envoyons la liste des contacts au journal de débogage afin de vérifier le fonctionnement du code.

Test de votre code dans la Developer Console

Dans la Developer Console, cliquez sur Debug (Débogage) | Open Execute Anonymous Window (Ouvrir la fenêtre d’exécution anonyme).
Dans la fenêtre d’exécution anonyme, attribuez les résultats de la requête à la nouvelle liste :
```
List<Contact> listOfContacts = [SELECT FirstName, LastName FROM Contact LIMIT 2];
```
Sur la ligne suivante, envoyez la liste listOfContacts au journal de débogage :
```
system.debug(listOfContacts);
```
Cochez la case Ouvrir le journal.
Cliquez sur Execute (Exécuter).
Au bas de la fenêtre Journal d’exécution, cochez la case Déboguer uniquement.
Les deux premiers éléments du journal de débogage doivent se présenter comme suit :
Si une requête ne trouve aucun résultat, elle renvoie tout de même une liste, mais celle-ci est vide :

[2]|DEBUG|()

Que se passe-t-il donc ?

Flèche SELECT FirstName, LastName FROM Contact LIMIT 2 pointant vers l’icône d’objet Contact dans un nuage. Une deuxième flèche envoyant des données correspondant à la requête à la classe Apex pointe vers une liste de contacts. 1. FirstName = Rose, LastName = Gonzalez. 2. FirstName = Sean, LastName = Forbes.

Lorsque notre code s’exécute, il traite d’abord la requête :

SELECT FirstName, LastName FROM Contact LIMIT 2

La requête trouve tous les contacts et obtient le prénom et le nom de chaque enregistrement. Ensuite, notre code ajoute les données sélectionnées à partir de ces enregistrements de contact à une liste nommée listOfContacts.

Enfin, à la ligne 2, System.debug affiche le contenu de listOfContacts.

Exécution des requêtes SOQL dans Apex

Dans l’unité précédente, vous avez utilisé l’éditeur de requête pour renvoyer des données dans un tableau. Dans cette unité, vous avez utilisé la fenêtre d’exécution anonyme pour exécuter une requête et envoyer les résultats au journal de débogage. C’est suffisant pour le moment, mais vos utilisateurs n’exécuteront pas de requêtes dans la Developer Console. Vous avez besoin d’un moyen de renvoyer des données dans l’interface utilisateur de votre organisation. Les classes et méthodes Apex permettent de le faire. Voyons comment exécuter une requête SOQL et manipuler ses résultats dans Apex.

Nous commençons par créer une méthode Apex dans une classe Apex. Cette méthode Apex exécute notre requête pour sélectionner les données que nous voulons.

Dans la Developer Console, cliquez sur File (Fichier) | New (Nouveau) | Apex Class (Classe Apex).
Nommez la classe ContactUtility, puis cliquez sur OK.
La classe s’ouvre, affichant le code qui déclare la classe et laisse de l’espace pour le corps de la classe.
À la ligne 2, ajoutez une méthode nommée viewContacts.
```
public static void viewContacts(){
}
```
À la ligne 3, dans la méthode viewContacts, collez le code qui exécute la requête et attribue les résultats à une nouvelle liste :
```
List<Contact> listOfContacts = [SELECT FirstName, LastName FROM Contact];
```
Enregistrez la classe.

Nous disposons maintenant des données que nous voulons dans la liste listOfContacts. Nous utiliserons une boucle for pour parcourir la liste, en créant le format de notre choix pour nos données de sortie.

Utilisation de boucles for pour parcourir une liste

Dans Programmation orientée objet pour les administrateurs, vous avez appris à traiter les éléments d’une liste, un par un, à l’aide d’une boucle for. Ici, nous utilisons une boucle for pour associer le nom et le prénom de chaque contact afin de former son nom complet. Nous allons commencer par créer la boucle, puis nous traiterons chaque enregistrement au sein de celle-ci.

Pour déclarer une boucle for, nous avons besoin d’un nom de variable, de son type de données et du nom de la liste répétée par la boucle.

Dans une boucle for, nous ne nous référons pas directement à des objets spécifiques. Nous créons une variable pour représenter un par un les éléments de la liste dans la boucle. La variable sert d’espace réservé pour chaque élément de la liste. Il peut s’agir de n’importe quel nom de votre choix, mais faisons simple. Nous utiliserons con, pour « contact ». Ensuite, nous avons besoin du type de données de la variable, à savoir Contact, et du nom de la liste, à savoir listOfContacts. Voici le résultat lorsque nous regroupons ces éléments :

for (Contact con : listOfContacts){ //loop body}

Déclaration d’une boucle for

Dans la méthode viewContacts, après la requête SOQL, collez le code qui suit :
```
for (Contact con : listOfContacts){
    //loop body
}
```
Enregistrez la classe.

Nous avons interrogé la base de données (1), sélectionné des données, stocké les données dans une liste (2) et créé une boucle for (3).

1. La requête, Select FirstName, LastName FROM Contact LIMIT 2, alimente la liste listOfContacts (2). 3. La boucle for qui traite les contacts dans la liste listOfContacts : for(Contact con : listOfContacts){ //logic goes here}

Ensuite, dans la boucle, nous traitons les éléments de la liste. Pour terminer, nous voulons afficher chaque contact de listOfContacts au format suivant :

First Name:<contact's first name>, Last Name:<contact's last name> (Prénom:, Nom:)

Afin de référencer un champ d’un élément dans une liste, utilisez la notation par point pour spécifier l’objet et son champ (object.field). Par exemple, faites référence au champ FirstName d’un objet Contact dans la liste listOfContacts en mettant un point (le « point » dans la notation par point) entre con (la variable d’objet) et FirstName (le champ), comme suit :

con.FirstName

La liste contient des champs de prénom et de nom distincts. Dans Apex, nous combinons des valeurs de champ (et parfois également du texte littéral) à l’aide de la concaténation. (Vous vous êtes exercé à la concaténation dans Bases d’Apex pour les administrateurs.)

Pour rappel, lorsque vous concaténez, les données de champ sont représentées sous la forme object.field. Le texte littéral est entouré d’apostrophes droites. N’oubliez pas de mettre des espaces au début et à la fin du texte littéral lorsque cela est nécessaire. Utilisez le symbole plus ( + ) pour combiner des champs ou pour combiner un champ et du texte littéral.

Remplissons le corps de notre boucle for. Tout d’abord, pour chaque élément de la liste listOfContacts, nous combinons FirstName et LastName dans une nouvelle variable nommée fullname :

String fullName = 'First Name: ' + con.FirstName + ', Last Name: ' + con.LastName;

Vous remarquerez l’espace entre FirstName et LastName. La sortie doit se présenter comme suit :

First Name:Angela, Last Name:Carter (Prénom:Angela, Nom:Carter)

et non

FirstName:Angela,LastName:Carter (Prénom :Angela,Nom :Carter))

Après l’attribution d’une valeur à la variable fullName (type de données : String), nous insérons cette variable dans l’instruction de débogage à la ligne suivante :

system.debug(fullName);

Traitement des éléments de liste dans la boucle for

Dans la méthode viewContacts, remplacez //loop body par le code suivant :

String fullName = 'First Name: ' + con.FirstName + ', Last Name: ' + con.LastName;
system.debug(fullName);

Enregistrez la classe.

Votre code doit se présenter comme suit :

public class ContactUtility {
    public static void viewContacts(){
        List<Contact> listOfContacts = [SELECT FirstName, LastName FROM Contact];
        for (Contact con : listOfContacts){
            String fullName = 'First Name: ' + con.FirstName + ', Last Name: ' + con.LastName;
            system.debug(fullName);
        }
    }
}

Maintenant que nous disposons d’une classe, d’une méthode et d’une requête SOQL prêtes à l’emploi, exécutons le code et voyons s’il fonctionne. Pour exécuter le code Apex dans la fenêtre d’exécution anonyme, nous spécifions la classe et la méthode à l’aide de la notation par point.

Ouvrez la fenêtre d’exécution anonyme.
Dans la fenêtre Entrer du code Apex, remplacez le code existant par le code suivant :
```
ContactUtility.viewContacts();
```
Vérifiez que la case Ouvrir le journal est cochée.
Cliquez sur Execute (Exécuter).
Sélectionnez Debug Only (Déboguer uniquement).

Les six premières lignes de vos résultats doivent être les suivantes :

Journal d’exécution
Événement	Détails
USER_DEBUG	[5]\|DEBUG\|First Name: Rose, Last Name: Gonzalez
USER_DEBUG	[5]\|DEBUG\|First Name: Sean, Last Name: Forbes
USER_DEBUG	[5]\|DEBUG\|First Name: Jack, Last Name: Rogers
USER_DEBUG	[5]\|DEBUG\|First Name: Pat, Last Name: Stumuller
USER_DEBUG	[5]\|DEBUG\|First Name: Andy, Last Name: Young
USER_DEBUG	[5]\|DEBUG\|First Name: Tim, Last Name: Barr

Examinez ! Avec SOQL, une boucle for et la concaténation, vous avez récupéré des données de contact, attribué ces données à une liste, répété la liste et généré les résultats attendus. Voici la marche à suivre !

Besoin d'aide ?

En savoir plus