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.
Utilisez des points d'interrogation ("?") dans vos instructions SQL pour indiquer l'endroit où vos méthodes transmettent des valeurs à ces instructions. Par exemple : nom ou ?#.nom. nom doit faire référence à une propriété dans un objet java.util.Map<String> ou à un bean. Pour plus d'informations sur les marqueurs de paramètres, voir Marqueurs de paramètres pour les instructions SQL.
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 ces instructions SQL 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[][] 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 des nombres de mises à jour renvoyés 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.
Toutes les méthodes intégrées et annotées qui exécutent les instructions SQL devant faire partie de la mise à jour par lots 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" 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) 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 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.
Si une ou plusieurs exceptions SQLExceptions sont renvoyées par le pilote JDBC, elles sont encapsulées dans une exception UpdateManyException.
Si la méthode endBatch() provoque une exception UpdateManyException, votre application peut appeler la méthode int[][] getHeterogeneousUpdateCounts(), laquelle renvoie le nombre de mises à jour sous la forme d'un tableau d'entiers bidimensionnel, à l'instar de ce qu'elle renverrait si le traitement par lots aboutissait.