Syntaxe des méthodes annotées exécutant SQL sur les bases de données

Consultez les diagrammes suivants pour connaître la syntaxe des déclarations de méthodes annotées.

Les diagrammes de syntaxe et les descriptions des éléments de syntaxe sont décrits dans les sections qui suivent.

Pour comprendre les conventions utilisées dans les diagrammes de syntaxe, voir Comment lire les diagrammes de syntaxe.

Syntaxe permettant d'exécuter les instructions SQL DML sans curseurs ainsi que les instructions DDL

Utilisez cette syntaxe pour déclarer les méthodes annotées exécutant les instructions DML n'utilisant pas de curseur. Vous pouvez également utiliser cette syntaxe pour exécuter les instructions DDL.

Lire le diagrammeSauter le diagramme
>>-@Update--(--sql--=--"--instruction-SQL--"--)----------------->

>--+------------------------------------------------------------------------------------------+-->
   '-@Handler--(--+-parameterHandler--=--nom-classe--------------------------------------+--)-'   
                  +-resultHandler--=--nom-classe--+------------------------------------+-+        
                  |                               '-,--parameterHandler--=--nom-classe-' |        
                  '-rowHandler--=--nom-classe--+------------------------------------+----'        
                                               '-,--parameterHandler--=--nom-classe-'             

>--modificateurs--type-renvoi--nom-méthode--(--+--------------------------------+--+-----------------------------------+--);-><
                                               '-gestionnaire--nom-gestionnaire-'  | .-,-----------------------------. |       
                                                                                   | V                               | |       
                                                                                   '---type-paramètre--nom-paramètre-+-'       

Exemple

Voici un exemple de syntaxe pour une méthode exécutant une instruction SELECT :

@Select(sql = "SELECT PID, QUANTITY, LOCATION FROM HEATHR.INVENTORY WHERE PID = ?")
Inventory getInventory(String pid);

Voici un exemple de syntaxe pour une méthode exécutant une instruction INSERT :

@Update(sql = "INSERT INTO HEATHR.INVENTORY (PID, QUANTITY, LOCATION) VALUES (?, ?, ?)")
int createInventory(String pid, int quantity, String location);

Syntaxe permettant d'exécuter les instructions CALL

Utilisez cette syntaxe pour déclarer les méthodes annotées exécutant les instructions CALL.

Lire le diagrammeSauter le diagramme
>>-@Call--(--sql--=--"--instruction-SQL--"--)------------------->

>--+------------------------------------------------------------------------------------------------------+-->
   '-@Handler--(--+-callHandlerWithParameters--=--nom-classe--+------------------------------------+-+--)-'   
                  |                                           '-,--parameterHandler--=--nom-classe-' |        
                  '-parameterHandler--=--nom-classe--------------------------------------------------'        

>--modificateurs--type-renvoi--nom-méthode--(--+--------------------------------+--+-----------------------------------+--);-><
                                               '-gestionnaire--nom-gestionnaire-'  | .-,-----------------------------. |       
                                                                                   | V                               | |       
                                                                                   '---type-paramètre--nom-paramètre-+-'       

Exemple

@Call(sql = "Call MYSCHEMA.BONUS_INCREASE( :p_bonusfactor, :p_bonusmaxsumfordept, 
	  :p_deptswithoutnewbonuses, :p_countdeptsviewed, :p_countdeptsbonuschanged, 
	  :p_errormsg )")
StoredProcedureResult callBONUS_INCREASE(Bonus_increaseParam parms);

Syntaxe permettant d'exécuter les instructions SELECT

Utilisez cette syntaxe pour déclarer les méthodes annotées exécutant les instructions SELECT. Si vous utilisez l'annotation @Cursor, vous devez importer java.sql.ResultSet dans votre interface.

Lire le diagrammeSauter le diagramme
>>-@Select--(--sql--=--"--instruction-SQL--"--)----------------->

>--+-----------------------------------------------------------------------------------------+-->
   |                 .-,-------------------------------------------------------------------. |   
   |            (1)  V                                .-false-.                            | |   
   '-@Cursor--(--------+-allowStaticRowsetCursors--=--+-true--+--------------------------+-+-'   
                       |                 .-java.sql.ResultSet.CONCUR_READ_ONLY-.         |       
                       +-concurrency--=--+-java.sql.ResultSet.CONCUR_UPDATABLE-+---------+       
                       |                 .-java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT--. |       
                       +-holdability--=--+-java.sql.ResultSet.HOLD_CURSORS_OVER_COMMIT-+-+       
                       |          .-java.sql.ResultSet.TYPE_FORWARD_ONLY-------.         |       
                       '-type--=--+-java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE-+---------'       
                                  '-java.sql.ResultSet.TYPE_SCROLL_SENSITIVE---'                 

>--+------------------------------------------------------------------------------------------+-->
   '-@Handler--(--+-parameterHandler--=--nom-classe--------------------------------------+--)-'   
                  +-resultHandler--=--nom-classe--+------------------------------------+-+        
                  |                               '-,--parameterHandler--=--nom-classe-' |        
                  '-rowHandler--=--nom-classe--+------------------------------------+----'        
                                               '-,--parameterHandler--=--nom-classe-'             

>--modificateurs--type-renvoi--nom-méthode--(--+--------------------------------+--+-----------------------------------+--);-><
                                               '-gestionnaire--nom-gestionnaire-'  | .-,-----------------------------. |       
                                                                                   | V                               | |       
                                                                                   '---type-paramètre--nom-paramètre-+-'       

Remarques:
  1. Vous pouvez utiliser une seule fois une option dans une annotation@Cursor.

Exemple

@Select (sql="select PUBLISHER_ID, BOOK_NAME, BOOK_ID, COUNTY 
	  from BOOKS WHERE STATE='CALIFORNIA'")
@Cursor (concurrency = ResultSet.CONCUR_READ_ONLY, 
	  type=ResultSet.TYPE_FORWARD_ONLY, 
	  holdability=ResultSet.HOLD_CURSORS_OVER_COMMIT)
Iterator<Books> getBooksInCaliforniaAndNameCursor ();

Syntaxe destinée aux mises à jour et aux suppressions positionnées

Utilisez cette syntaxe lorsque vous déclarer des méthodes annotées pour effectuer des mises à jour et des suppressions positionnées. Si vous utilisez l'annotation @Cursor, vous devez importer java.sql.ResultSet dans votre interface.

Pour plus d'informations sur l'écriture des méthodes annotées pour les mises à jour et suppressions positionnées, voir Exécution de mises à jour et de suppressions positionnées.

Syntaxe de la méthode exécutant l'instruction SELECT qui permet d'ouvrir et de nommer un curseur pour une mise à jour ou une suppression positionnée.

Lire le diagrammeSauter le diagramme
>>-@Select--(--sql--=--"--instruction-SQL--"--)----------------->

>--+------------------------------------------------------------------------------------------------------------------------------+-->
   |                                               .-,-----------------------------------------------------------------------.    |   
   |                                               V  (1)                  .-java.sql.ResultSet.CONCUR_READ_ONLY-.           |    |   
   '-@Cursor--(--cursorName--=--"--nom-curseur--"--------+-concurrency--=--+-java.sql.ResultSet.CONCUR_UPDATABLE-+---------+-+--)-'   
                                                         |                 .-java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT--. |          
                                                         +-holdability--=--+-java.sql.ResultSet.HOLD_CURSORS_OVER_COMMIT-+-+          
                                                         |          .-java.sql.ResultSet.TYPE_FORWARD_ONLY-------.         |          
                                                         '-type--=--+-java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE-+---------'          
                                                                    '-java.sql.ResultSet.TYPE_SCROLL_SENSITIVE---'                    

>--+---------------------------------------------------------------------------------------+-->
   '-@Handler--(--+-parameterHandler--=--nom-classe-----------------------------------+--)-'   
                  '-rowHandler--=--nom-classe--+------------------------------------+-'        
                                               '-,--parameterHandler--=--nom-classe-'          

>--modifiers--+-Iterator-----------+--nom-méthode--(--+--------------------------------+--+-----------------------------------+--);-><
              '-java.sql.ResultSet-'                  '-gestionnaire--nom-gestionnaire-'  | .-,-----------------------------. |       
                                                                                          | V                               | |       
                                                                                          '---type-paramètre--nom-paramètre-+-'       

Remarques:
  1. Vous pouvez utiliser une seule fois ces options dans une annotation @Cursor.

Syntaxe de la méthode exécutant une instruction UPDATE ou DELETE utilisant le curseur nommé

Lire le diagrammeSauter le diagramme
>>-@Update--(--sql--=--"--instruction-SQL--"--,--positionedCursorName--=--"--nom-curseur--"--)-->

>--+-------------------------------------------------+---------->
   '-@Handler--(--parameterHandler--=--nom-classe--)-'   

>--modificateurs--type-renvoi--nom-méthode--(--+--------------------------------+--+-----------------------------------+--);-><
                                               '-gestionnaire--nom-gestionnaire-'  | .-,-----------------------------. |       
                                                                                   | V                               | |       
                                                                                   '---type-paramètre--nom-paramètre-+-'       

Exemple

Voici un exemple de syntaxe pour une méthode exécutant une instruction SELECT permettant d'ouvrir un curseur pour les mises à jour et les suppressions positionnées :

@Select (sql="select PUBLISHER_ID, BOOK_NAME, BOOK_ID, COUNTY 
	  from BOOKS WHERE STATE='CALIFORNIA' FOR UPDATE OF PUBLISHER_ID")
@Cursor (concurrency = ResultSet.CONCUR_UPDATABLE, 
	  type=ResultSet.TYPE_FORWARD_ONLY, 
	  holdability=ResultSet.HOLD_CURSORS_OVER_COMMIT,
	  cursorName="TESTCURSORITER")
Iterator<Books> getBooksInCaliforniaAndNameCursor ();

Voici un exemple de syntaxe pour une méthode exécutant une instruction UPDATE et utilisant le curseur :

@Update (sql="update BOOKS SET PUBLISHER_ID = :publisher_id", 
	  positionedCursorName = "TESTCURSORITER")
int updateBooksByUsingNamedCursor (Book b);
Avertissement : N'insérez pas une clause WHERE dans l'instruction UPDATE ou DELETE. Si vous le faîtes, pureQuery répertorie une erreur lorsque vous créez une implémentation de votre interface, si vous configurez les options pour la journalisation avant d'exécuter cet utilitaire. pureQuery ajoute une clause WHERE CURRENT OF à l'instruction.

Description des éléments de syntaxe

@Call
Indique que la méthode exécute une instruction SQL CALL.
sql
Indique l'instruction CALL pour la méthode à exécuter.
@Cursor
Indique les attributs du curseur pour une instruction SELECT. Vous pouvez utiliser cette annotation uniquement si vous utilisez également l'annotation @Select.
allowStaticRowsetCursors
Spécifie si le curseur associé à une instruction SELECT est un curseur d'ensemble de lignes lorsque l'instruction est exécutée en mode statique, si vous utilisez une source de données DB2 Universal Database for z/OS Version 8 (mode nouvelle fonction) ou DB2 Version 9.1 for z/OS et le IBM® Data Server Driver pour JDBC et SQLJ pour vous connecter à cette source de données.
false
Indique que le curseur associé à une instruction SELECT n'est pas un curseur de groupe de lignes lorsque l'instruction est exécutée en mode statique.
Il s'agit de la valeur par défaut.
true
Indique que le curseur associé à une instruction SELECT est un curseur de groupe de lignes lorsque l'instruction est exécutée en mode statique. Lorsque vous paramétrez la valeur sur true, vous devez respecter ces limitations :
  • L'instruction SQL que vous souhaitez autoriser pour utiliser des curseurs d'un groupe de lignes est une instruction SELECT que vous indiquez dans une annotation @Select pour la méthode.
  • Le type de renvoi de la méthode annotée ne dirige pas pureQuery pour sélectionner une seule ligne de la base de données.
  • Aucune des colonnes des résultats de requête ne contiennent des données de type LOB ou XML.
  • Le curseur que l'instruction ouvre est en lecture seule. Si un curseur statique actualisable utilise des ensembles de lignes, le résultat est imprévisible.

    pureQuery considère qu'une instruction est actualisable si l'une de ces conditions est vraie :

    • L'attribut d'accès concurrent n'est pas défini sur java.sql.ResultSet.CONCUR_UPDATABLE.
    • L'instruction SQL ne contient pas de clause FOR UPDATE.
    pureQuery considère qu'une instruction est en lecture seule si elle n'est pas actualisable.
  • La méthode annotée n'est jamais appelée par une procédure Java enregistrée.
concurrency
java.sql.ResultSet.CONCUR_READ_ONLY
Constante entière spécifiant que le curseur refuse les mises à jour lorsque le résultat de la requête est ouvert.
java.sql.ResultSet.CONCUR_UPDATABLE
Constante entière spécifiant que le curseur autorise les mises à jour lorsque le résultat de la requête est ouvert.
cursorName
Indique le nom d'un curseur à utiliser pour les mises à jour et les suppressions positionnées. Le nom ne peut pas commencer par DB2JCCCURSOR ou par DB_PDQ. Le nom doit également être conforme aux règles d'attribution aux curseurs de votre base de données.
holdability
java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT
Constante entière indiquant que le curseur est fermé à la fin d'une transaction.
java.sql.ResultSet.HOLD_CURSORS_OVER_COMMIT
Constante entière indiquant que le curseur reste ouvert à la fin d'une transaction.
type
java.sql.ResultSet.TYPE_FORWARD_ONLY
Constante entière indiquant que le curseur ne peut se déplacer que vers l'avant.
java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE
Constante entière indiquant que le curseur peut se déplacer vers l'avant et vers l'arrière. Le résultat de la requête produit un cliché des données.
java.sql.ResultSet.TYPE_SCROLL_SENSITIVE
Constante entière indiquant que le curseur peut se déplacer vers l'avant et vers l'arrière. Le résultat de la requête reflète les modifications apportées aux données lorsque le curseur est mis en suspens.
@Handler
Dirige pureQuery pour utiliser une classe d'implémentation fournie au lieu de la procédure par défaut de pureQuery lors de l'exécution de la méthode annotée.
callHandlerWithParameters
Indique une implémentation de l'interface com.ibm.pdq.handlers.CallHandlerWithParameters<CAL>. Si vous définissez cet attribut, pureQuery utilise la classe pour traiter les résultats d'une procédure SQL enregistrée CALL et créer l'objet renvoyé par la méthode annotée. La méthode handleCall() de la classe traite les résultats de l'appel de la procédure SQL enregistrée et renvoie un objet de type <CAL> décrivant les résultats.
parameterHandler
Indique une implémentation de l'interface com.ibm.pdq.handlers.ParameterHandler. Si vous définissez cet attribut, pureQuery utilise la classe pour définir les valeurs des paramètres de l'objet java.sql.PreparedStatement pour l'instruction SQL.
Si la méthode annotée appelle une procédure mémorisée, ParameterHandler doit enregistrer tous les paramètres OUT et INOUT.
resultHandler
Indique une implémentation de l'interface com.ibm.pdq.handlers.ResultHandler<RES>. Si vous définissez cet attribut, pureQuery utilise la classe pour créer l'objet renvoyé par la méthode annotée. La méthode handle() de la classe traite java.sql.ResultSet pour une instruction SQL et renvoie le contenu dans un objet de type <RES>.
rowHandler
Indique une implémentation de l'interface com.ibm.pdq.handlers.RowHandler<ROW>. Si vous définissez cet attribut, pureQuery utilise la classe pour créer l'objet représentant chaque ligne de résultats de la requête renvoyés par la méthode annotée. Cette méthode handle() de la classe traite une seule ligne de java.sql.ResultSet pour une instruction SQL et renvoie le contenu dans un objet de type <ROW>.
@Select
Indique que la méthode exécute une instruction SQL SELECT.
sql
Indique l'instruction SELECT pour la méthode à exécuter.
@Update
Indique que la méthode exécute une instruction SQL DML (data manipulation language) ou DDL (data definition language).
sql
Indique l'instruction SQL pour la méthode à exécuter.
positionedCursorName
Indique le nom d'un curseur à utiliser pour les mises à jour et les suppressions positionnées. Le nom doit être défini dans l'attribut cursorName de l'annotation @Select.
Lorsque vous générez une implémentation de l'interface déclarant la méthode utilisant cet attribut, pureQuery ajoute la clause requise WHERE CURRENT OF à l'instruction UPDATE ou DELETE.
nom-méthode
Spécifie le nom de la méthode d'interface.
type-paramètre nom-paramètre

Pair d'arguments répétitifs indiquant les types et les noms des arguments prévus lors de l'appel de la méthode.

Ces paramètres sont comparés aux marqueurs de paramètres définis dans l'instruction SQL conformément aux règles ci-dessous. Ces paramètres peuvent être de type scalaire, des classes de bean ou des objets Map. Si l'instruction SQL utilise la notation :nom pour les références des paramètres, le premier type de paramètre doit être un bean ou une mappe Map. Les noms de propriétés du bean ou de la mappe Map sont utilisés pour établir une comparaison avec les occurrences :nom dans la chaîne SQL.

Si SQL utilise la notation ? pour les références de paramètres, vous pouvez fournir uniquement des valeurs scalaires.

Si la notation ?n et ?n.nom est utilisée, les paramètres de la méthode doivent être soit tous de type scalaire, soit une combinaison de classes de beans et d'objets Map.

Les paramètres définis généralement utilisés sont uniquement des variables d'entrée. Cependant, dans le cas des paramètres OUT ou INOUT d'une instruction SQL CALL, ils peuvent représenter des variables de sortie. Pour plus de détails, reportez-vous à la section précédente qui présente la prise en charge de l'instruction CALL.

type-renvoi
Indique le type de renvoi de la méthode

Ce tableau présente les types de renvoi possibles pour les méthodes utilisant les annotations @Call, @Select, et @Update.

Tableau 1. Légende des types de renvoi du tableau
Abréviation Signification
CAL CallHandlerWithParameters
I Iterator
L List
M Map
O Object
R java.sql.ResultSet
RES ResultHandler
ROW RowHandler
S String
SPR StoredProcedureResult
T Type de primitif int, classe d'encapsulation pour un type de primitif Java, type d'objet simple ou bean. T est autorisé à être un type int uniquement avec les annotations @Update et, dans les annotations @Update, T doit être de type int.
Tableau 2. Types de renvoi en fonction du type d'annotation
    Annotation
    @Call @Select @Update
Type de renvoi CAL    
int    
int[]    
I<M<S,O>>  
I<T>  
L<M<S,O>>  
L<T>  
M<S,O>    
M<S,O>[]  
R    
RES    
ROW    
ROW[]    
L<ROW>    
I<ROW>    
SPR    
<T>    
<T>[]  
void  
Remarque : Si vous utilisez une procédure mémorisée qui renvoie plusieurs objets ResultSet et que vous souhaitez utiliser tous ces objets, utilisez le type de renvoi StoredProcedureResult ou utilisez une implémentation de l'interface CallHanderWithParameters<CAL>. Tous les autres types de renvoi que vous pouvez utiliser avec l'annotation @Call renvoient uniquement le premier objet ResultSet d'un appel vers une procédure mémorisée.

Lorsque vous utilisez une méthode annotée, ne précisez pas qu'une annotation @Select ou @Call renvoie un type Java primitif, ou un objet Array, List ou Iterator de type Java primitif.

Les informations relatives aux valeurs SQL null sont perdues chaque fois que les informations demandées par SQL sont stockées dans un type Java primitif. De plus, Java nécessite qu'une méthode générique, spécifiant une classe générique <T> de type <type Java primitif>.class, renvoie une instance de la classe d'encapsulation appropriée à ce type Java primitif.

Par exemple, Java n'autorise pas les appels de méthode tels que :
int tCount = myGenericMethod( int.class );
où la définition de myGenericMethod est :
<T> T myGenericMethod( Class<T> cl );
La classe déclarée de tCount doit être Integer.
Integer tCount = myQuery.myGenericMethod( Integer.class );

Cette restriction est associée à l'utilisation des méthodes génériques même s'il n'y a pas d'utilisation explicite des signatures de la méthode générique (aucune utilisation des informations de <T> et de la classe de renvoi) dans les signatures de méthode définies dans votre interface annotée. Cette restriction est nécessaire car l'implémentation générée d'une interface annotée utilise des méthodes identiques en certains points aux API de la méthode intégrée. En particulier, l'implémentation utilise des méthodes génériques.

void
Indique que la méthode ne renvoie rien.
java.sql.ResultSet
Indique qu'un objet ResultSet est renvoyé. ResultSet est en lecture seule.
StoredProcedureResult
StoredProcedureResult n'est valide qu'en tant que type de renvoi pour une méthode annotée @Call qui appelle une instruction CALL. Après l'exécution de la méthode, l'objet StoredProcedureResult peut être utilisé pour traiter plusieurs résultats de requête renvoyés par la routine stockée ou pour accéder aux paramètres de sortie.
int
Indique que la méthode renvoie un compte de lignes mises à jour.
int[]
Indique que la méthode renvoie un tableau d'entiers. Chaque élément du tableau enregistre le nombre de mises à jour pour une exécution unique de l'instruction SQL DML (Data Manipulation Language). Utilisez ce type de renvoi pour les mises à jour par lots.
List<Map<String,Object>>
Indique que la méthode renvoie une liste d'objets Map<String,Object>.
Pour plus d'informations, voir la description des objets Map<String,Object> renvoyés.

Un objet ResultSet de base de données sous-jacent est fermé.

List<T>
Indique qu'un objet List de type T est renvoyé. Lorsque l'instruction SQL indiquée est une requête, chaque élément correspond à une ligne du résultat de la requête.

Lorsqu'un objet <T> est renvoyé par une instruction CALL, la source de données contenue dans l'objet est le premier objet ResultSet que la procédure mémorisée renvoie.

Lorsqu'un objet <T> est renvoyé par une instruction SELECT, la source de données contenue dans l'objet est le résultat de la requête.

Toutes les lignes du résultat de la requête sont matérialisées lorsque la méthode est appelée et tout objet ResultSet de base de données sous-jacent est fermé.
Map<String,Object>
Indique qu'un objet Map<String,Object> est créé et renvoyé. Les libellés de la colonne de renvoi du résultat de la requête deviennent les clés de la mappe. Les libellés de la colonne sont convertis en minuscules pour une plus grande conformité au style de codage Java courant. Les valeurs de la colonne correspondante d'une ligne du résultat de la requête deviennent les valeurs de l'objet Map. Si plusieurs lignes qualifient, la valeur de la première ligne est renvoyée.

Lorsqu'un objet Map<String,Object> est renvoyé par une instruction CALL, la source de données contenue dans l'objet est le premier objet ResultSet que la procédure mémorisée renvoie.

Lorsqu'un objet Map<String,Object> est renvoyé par une instruction SELECT, la source de données contenue dans l'objet est le résultat de la requête.

Un objet ResultSet de base de données sous-jacent est fermé.

Map<String,Object>[]
Indique qu'un tableau d'objets Map<String,Object> est créé et renvoyé. reportez-vous à la description des objets Map<String,Object> renvoyés.

Un objet ResultSet de base de données sous-jacent est fermé.

<T>

Indique qu'un scalaire ou un bean est renvoyé. Un scalaire peut être une classe d'encapsulation telle que Double, ou encore String, Date ou Timestamp.

Si l'instruction SQL fournie est une requête et que plusieurs lignes qualifient, la valeur de la première ligne est renvoyée.

Un objet ResultSet de base de données sous-jacent est fermé.

<T>[]
Indique qu'un tableau de type T est renvoyé, tel que Employee[], Integer[] ou String[].
  • Lorsque l'instruction SQL indiquée est une requête, chaque élément correspond à une ligne du résultat de la requête.
  • Lorsqu'un objet <T> est renvoyé par une instruction CALL, la source de données contenue dans l'objet est le premier objet ResultSet que la procédure mémorisée renvoie.
  • Lorsque l'instruction SQL donnée n'est pas ni requête, ni une instruction CALL renvoyant ResultSet, chaque élément du tableau doit être de type int, paramétré sur le nombre de mises à jour renvoyé des instructions.
Toutes les lignes du résultat de la requête sont matérialisées lorsque la méthode est appelée et tout objetResultSet de base de données sous-jacent est fermé.
Iterator<Map<String,Object>>

Indique qu'un Iterator d'objets Map<String,Object> est renvoyé. Pour plus d'informations, voir la description des objets Map<String,Object> renvoyés.

Les lignes du résultat de la requête sont récupérées de la source de données lorsque l'application exécute chaque opération next() sur l'Iterator.

Les itérateurs de pureQuery sont de type ResultIterator. Vous devez les fermer avec la méthode ResultIterator.close() une fois que vous avez fini de les utiliser.

Iterator<T>

Indique qu'un objet Iterator est renvoyé avec chaque élément correspondant à une ligne. Le type T paramétré doit être défini.

Les lignes du résultat de la requête sont récupérées de la source de données lorsque l'application exécute chaque opération next() sur l'Iterator.

Lorsqu'un objet <T> est renvoyé par une instruction CALL, la source de données contenue dans l'objet est le premier objet ResultSet que la procédure mémorisée renvoie.

Lorsqu'un objet <T> est renvoyé par une instruction SELECT, la source de données contenue dans l'objet est le résultat de la requête.

Les itérateurs de pureQuery sont de type ResultIterator. Vous devez les fermer avec la méthode ResultIterator.close() une fois que vous avez fini de les utiliser.

sql
Indique l'instruction SQL à exécuter lorsque la méthode associée est appelée. L'instruction SQL doit être valide pour la base de données cible. pureQuery définit également un nombre de marqueurs de paramètres. Ces marqueurs correspondent aux paramètres d'entrée des méthodes intégrées ou annotées.
Certains pilotes JDBC exigent que vous utilisiez la séquence d'échappement JDBC/ODBC si vous souhaitez exécuter une instruction CALL.

Commentaires