Retrait de Async SOQL pour les Big Objects par Salesforce

Salesforce retire et ne prend plus en charge la fonctionnalité Async SOQL pour les Big Objects avec la version Summer ’23. 

Dans le cadre de notre amélioration permanente de Salesforce Platform, nous retirons la fonctionnalité Async SOQL, car nous nous éloignons des technologies qui prennent en charge Async SOQL. Elle est remplacée par des API que les clients connaissent mieux.

Quel est l'impact de cette modification ? 

Une fois votre organisation mise à niveau vers la version Summer ’23, vous devez utiliser l'API de traitement en masse ou un Apex par lots pour interroger ou générer des rapports sur des Big Objects personnalisés. Les tâches qui exécutent Async SOQL ne sont pas disponibles avec cette version. Nous recommandons de tester le remplacement de la fonctionnalité Async SOQL dans des organisations sandbox avant la publication de Summer ’23. Pour connaître la date de remise à niveau de votre organisation, consultez le site Trust de Salesforce.

CRM Analytics peut-il charger des données à partir de BigObjects ?

Oui, CRM Analytics utilise des requêtes d'API de traitement en masse pour charger les données.

Que dois-je utiliser pour interroger plus de 50 000 enregistrements ?

L'API de traitement en masse et un Apex par lots peuvent interroger des résultats supérieurs à 50 000 enregistrements. Cependant, Salesforce suggère d'utiliser un Apex par lots en déclenchant des tâches Apex par lots supplémentaires.

Comment procéder si j'ai 1 million d'enregistrements et que mes requêtes de traitement en masse ou Apex expirent ?

Si vous avez de nombreux enregistrements et souhaitez les interroger plus efficacement, vous pouvez mettre votre index à jour afin d'inclure les champs utiles pour interroger ou changer la méthode stockage de vos données dans des Big Objects. Si vous divisez les données en Big Objects séparés, vous pouvez utiliser Async SOQL pour migrer les données vers ces nouveaux objets. Si vous souhaitez utiliser Async SOQL, pensez à migrer les données avant le retrait de cette fonctionnalité dans la version Summer ’23.

Que se passe-t-il si je choisis de ne pas utiliser de Big Objects ?

Si vous choisissez une autre solution, vous pouvez utiliser Database.deleteImmediate pour supprimer vos données. Salesforce ne supprime pas vos données. Vous devez les supprimer vous-même.

Quelles sont les alternatives à Async SOQL et comment puis-je les utiliser ?

Vous pouvez interroger des Big Objects en utilisant l'API de traitement en masse et un Apex par lots. Consultez les exemples d'alternatives suivants pour les requêtes Async SOQL existantes.

Journal d'audit de champ

Cet exemple montre comment interroger FieldHistoryArchive et analyser les résultats dans un fichier CSV.

Exemple d'URI

/services/data/vXX.X/jobs/query

Exemple de requête Post

{ "operation": "query", "query": "SELECT ParentId, FieldHistoryType, Field, Id, NewValue, OldValueFROM FieldHistoryArchive WHERE FieldHistoryType = ‘Account’ AND CreatedDate > LAST_MONTH" }

Utilisez la ressource Get Results for a Query Job.

Exemple de requête CURL

curl --include --request GET \ --header "Authorization: Bearer token" \ --header "Accept: text/csv" \ https://instance.salesforce.com/services/data/vXX.X/jobs/query/750R0000000zxr8IAA/results ?maxRecords=50000

Cette requête génère un fichier CSV à examiner pour les besoins d'audit.

Vue Customer 360

Apex par lots est une alternative à Async SOQL pour le traitement automatisé d'un Big Object, ou ApiEvent, ReportEvent, ListViewEvent. Cet exemple montre comment ajouter un traitement qui référence des données corrélées.

Exécutez une requête Apex par lots sur un Big Object, puis corrélez les informations de Contact associées à ce Big Object.

Remarque : Vous ne pouvez pas exécuter un nombre illimité de Big Objects dans Apex. Le segment de mémoire Apex est limité à 6 Mo pour un traitement synchrone et à 12 Mo pour un traitement asynchrone. Par exemple, si vous avez 6000 entrées de 1 Ko chacune, vous pouvez stocker 6000 enregistrements seulement en mémoire.

public class QueryBigObjectAndContact implements Database.Batchable<sObject> {     private String key;     public QueryBigObjectAndContact(String keyParam) {         key = keyParam     }          public Iterable<SObject> start(Database.BatchableContext BC) {         return [SELECT Big_Object_Field__c, Account__c FROM Big_Object__b WHERE Big_Object_Primary_Key__c > key LIMIT 50000]     }     public void execute(Database.BatchableContext bc, List<Big_Object__b> bos){         // process the batch of Big Objects and associate them to Accounts         Map<Id, Big_Object__b> accountIdToBigObjectMap = new Map<Id, Big_Object__b>();         for (Big_Object__b bigObject : bos) {             accountIdToBigObjectMap.put(bigObject.Account__c, bigObject);             key = bigObject.Big_Object_Primary_Key__c         }         Map<Id, Account> = new Map<Id, Account>(             [SELECT Id, Name, ... FROM Account WHERE Id IN :accountIdToBigObjectMap.keySet()]         );         for (Id accountId : accountMap.keySet()) {             Big_Object__b bigObject = accountIdToBigObjectMap.get(accountId);             Account account = accountMap.get(accountId);             // perform any actions that integrate the Big Object and Account         }     }     public void finish(Database.BatchableContext bc){         // Daisy chain additional calls using the primary key of the Big Object to get around the 50k governor limit         QueryBigObjectAndContact nextBatch = new QueryBigObjectAndContact(key);         Database.executeBatch(nextBatch);     } }

Surveillance des événements en temps réel

Cet exemple montre comment interroger et analyser un Big Object Event en utilisant le contenu d'un champ.

public class EventMatchesObject implements Database.Batchable<sObject> {     private String lastEventDate;     public EventMatchesObject(String lastEventDateParam) {         lastEventDate = lastEventDateParam;     }     public Iterable<SObject> start(Database.BatchableContext bc) {         return [SELECT EventDate, EventIdentifier, QueriedEntities, SourceIp, Username, UserAgent FROM ApiEvent WHERE EventDate > lastEventDate LIMIT 50000]     }     public void execute(Database.BatchableContext bc, List<ApiEvent> events){         // Process this list of entities if a certain attribute matches         for (ApiEvent event: events) {             String objectString = 'Patent__c';             String eventIdentifier = event.EventIdentifier;             if (eventIdentifier.contains(objectString) {                 // Perform actions on the event that contains 'Patent__c'             }             lastEventDate = format(event.EventDate);         }     }     public void finish(Database.BatchableContext bc){                  // Daisy chain additional calls using EventDate or other filter fields to get around the 50k governor limit         EventMatchesObject nextBatch = new EventMatchesObject(lastEventDate);         Database.executeBatch(nextBatch);     } }

Requêtes agrégées

Cet exemple montre une alternative pour les requêtes agrégées similaires à la méthode COUNT().

public class CountBigObjects implements Database.Batchable<sObject> {     private Integer recordsCounted;     private String key;     public CountBigObjects(Integer recordsCountedParam, String keyParam) {         recordsCounted = recordsCountedParam         key = keyParam     }      public Iterable<SObject> start(Database.BatchableContext bc) {         return [SELECT Custom_Field__c FROM Big_Object__b LIMIT 25000]     }     public void execute(Database.BatchableContext bc, List<Big_Object__b> bos){         // process the batch of Big Objects and associate them to Accounts         Map<Id, Big_Object__b> accountIdToBigObjectMap = new Map<Id, Big_Object__b>();         for (Big_Object__b bigObject : bos) {             accountIdToBigObjectMap.put(bigObject.Account__c, bigObject);         }         Map<Id, Account> accountMap = new Map<Id, Account>(             [SELECT Id, Name, ... FROM Account WHERE Id IN :accountIdToBigObjectMap.keySet()]         );         for (Id accountId : accountMap.keySet()) {             Big_Object__b bigObject = accountIdToBigObjectMap.get(accountId);             Account account = accountMap.get(accountId);             // perform any actions that integrate the Big Object and Account         }     }     public void finish(Database.BatchableContext bc) {                  // Daisy chain additional calls using the primary key of the Big Object to get around the 50k governor limit         CountBigObjects nextBatch = new CountBigObjects(recordsCounted, key);         Database.executeBatch(nextBatch);     } }

Si vous avez des questions complémentaires, ouvrez une requête auprès du support via l'Aide de Salesforce. Pour prendre connaissance de l'approche Salesforce sur le retrait de produits et de fonctionnalités, lisez Philosophie de retrait de fonctionnalité.