Toutes les instructions SQL suivantes que votre application demande à exécuter sur la connexion indiquée sont mises en file d'attente dans la mémoire. pureQuery renvoie des résultats factices à votre application pour indiquer que chaque instruction s'est exécutée avec succès, même si les instructions ne se sont pas réellement exécutées. Vous appelez une méthode qui indique à pureQuery que vous terminez une mise à jour par lots. A ce stade, pureQuery exécute toutes les instructions SQL mises en file d'attente.
data.startBatch(HeterogeneousBatchKind.heterogeneousModify_);
Après avoir appelé cette méthode, pureQuery met en file d'attente toutes les instructions SQL que votre application demande par rapport à la même implémentation de l'interface Data.
pureQuery continue à placer en file d'attente les instructions INSERT, UPDATE et DELETE jusqu'à ce que l'application appelle la méthode endBatch().
A mesure que pureQuery place les instructions en file d'attente, il renvoie des résultats factices à votre application pour indiquer que les instructions se sont exécutées avec succès.Votre application peut demander à exécuter uniquement les instructions INSERT, UPDATE et DELETE. pureQuery rejette tous les autres types d'instruction SQL et ces instructions ne sont pas exécutées sur votre connexion. Si votre application soumet un autre type d'instruction SQL, pureQuery émet une exception et efface toutes les instructions qu'il a mis en file d'attente pour le traitement par lots. De plus, pureQuery n'exécute pas l'instruction qui a provoqué l'exception.
Si votre application appelle à nouveau la méthode startBatch() avant d'appeler la méthode endBatch(), pureQuery arrête le processus par lots, efface les instructions mises en file d'attente et émet une exception RuntimeException.
int[][] batchResult = data.endBatch();
pureQuery exécute les instructions placées en file d'attente en un aller-retour sur le réseau. La méthode renvoie un tableau d'entiers bidimensionnel contenant le compage de mises à jour renvoyé par les méthodes update() et updateMany(). La taille de la première dimension est égale au nombre de requêtes soumises par votre application pour exécuter des instructions SQL. La taille de la deuxième dimension est soit :HeterogeneousBatchKind getBatchKind();
Si un traitement par lots est en cours, la méthode renvoie heterogeneousModify_. So aucun traitement par lots n'est en cours, la méthode renvoie hetergeneousNone_.Votre application peut appeler la méthode updateMany() entre les appels aux méthodes startBatch() et endBatch(). La méthode updateMany() peut exécuter une instruction SQL INSERT, UPDATE ou DELETE à plusieurs reprises par rapport à un seul objet de base de données. Pour plus d'informations sur cette méthode, voir Mises à jour par lots effectuées sur des objets de base de données uniques à l'aide de la méthode updateMany() de l'interface Data.
Pour être incluses dans la mise à jour par lots, toutes les méthodes intégrées et annotées qui exécutent les instructions SQL doivent partager le même objet Data. Cela s'effectue un peu différemment, selon les types de méthode pureQuery utilisés par l'application de l'utilisateur.
Data data = DataFactory.getData(jdbcConnection);
data.startBatch(...);
// autres méthodes Data utilisant l'instance Data "data"
int[][] batchResult = data.endBatch();
Une fois que l'application a appelé la méthode endBatch(), elle peut éventuellement utiliser l'instance de Data à des fins différentes.Data data = DataFactory.getData (jdbcConnection);
// utilisez maintenant "data" pour instancier les interfaces qui seront utilisées
EmployeeInterface emp = DataFactory.getData (EmployeeInterface.class, data);
DepartmentInterface dept = DataFactory.getData (DepartmentInterface.class, data);
data.startBatch(...);
// autres méthodes Data et Annotated (EmployeeInterface et DepartmentInterface)
int[][] batchResult = data.endBatch();
EmployeeInterface emp = DataFactory.getData (EmployeeInterface.class, jdbcConnection);
DepartmentInterface dept = DataFactory.getData (DepartmentInterface.class, (Data) emp);
Data data = (Data) emp;
data.startBatch(...);
// other Annotated (EmployeeInterface and DepartmentInterface) methods
int[][] batchResult = data.endBatch();
Pour la base de données, toutes les instructions SQL entre startBatch() et endBatch() représentent une transaction. L'appel de commit() ou rollback() après startBatch() et avant endBatch() provoque l'arrêt de l'exécution du traitement par lots et les requêtes placées en file d'attente sont perdues. Enfin, pureQuery émet une exception RuntimeException.