Mises à jour hétérogènes par lots avec des paramètres

Avec pureQuery, vous pouvez regrouper des instructions INSERT, UPDATE et DELETE faisant référence à des tables différentes. Ces mises à jour hétérogènes par lots permettent de mettre à jour toutes les tables associées en un seul aller-retour vers le serveur sur le réseau. Vous appelez ainsi une méthode qui indique à pureQuery que vous lancez une mise à jour par lots.
Restriction : Pour utiliser cette fonction, votre application doit exécuter les instructions SQL sur une base de données DB2 qui s'exécute sous Linux, UNIX, Windows ou z/OS. L'application doit se connecter à cette base de données à l'aide d'IBM® pour JDBC et SQLJ. Voir la configuration système requise pour savoir quelle version de ce pilote est requise pour la version de pureQuery que vous utilisez.

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.

Traitement par lots

  1. Appelez la méthode startBatch() pour indiquer le début du traitement par lots des 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 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.

  2. Appelez la méthode endBatch() pour indiquer la fin du traitement par lots des instructions SQL et inviter pureQuery à exécuter les instructions placées en file d'attente.
    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 contenant le nombre 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 :
    1
    Indique qu'une méthode update() a été traitée par lots.
    n
    Si une méthode updateMany() a été traitée par lots, n est le nombre de lignes de données présentes dans la méthode updateMany().
Si votre application doit trouver si la méthode startBatch() a été soumise, mais pas encore la méthode endBatch(), votre application peut utiliser la méthode getBatchKind().
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.

Exigences

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.

Méthodes intégrées uniquement
Créez une instance de Data que vous pourrez utiliser pour la mise à jour par lots, comme dans cet exemple :
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.
Méthodes intégrées et méthodes annotées
Créez une instance de Data, puis transmettez cette instance de Data pour instancier les interfaces qui déclarent vos méthodes annotées, comme dans l'exemple suivant :
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();
Méthodes annotées uniquement
Instanciez la première interface, puis utilisez cette interface pour instancier toutes les autres interfaces. Les implémentations renvoyées par DataFactory prolongent une implémentation de l'interface Data. Pour appeler les méthodes Data dans l'implémentation, vous adaptez l'implémentation au type Data.
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();
Avertissement : L'unité d'exécution des objets de données n'est pas sécurisée. Ne les partagez pas entre plusieurs unités d'exécution. Utilisez un objet Data uniquement dans la même unité d'exécution que celle dans laquelle il a été créé.

Exceptions

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.


Commentaires