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.
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.
>>-@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);
Utilisez cette syntaxe pour déclarer les méthodes annotées exécutant les instructions CALL.
>>-@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);
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.
>>-@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-+-'
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 ();
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.
>>-@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-' >--modificateurs--+-Iterator-----------+--nom-méthode--(--+--------------------------------+--+-----------------------------------+--);->< '-java.sql.ResultSet-' '-gestionnaire--nom-gestionnaire-' | .-,-----------------------------. | | V | | '---type-paramètre--nom-paramètre-+-'
Syntaxe de la méthode exécutant une instruction UPDATE ou DELETE utilisant le curseur nommé
>>-@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);
pureQuery considère qu'une instruction est actualisable si l'une de ces conditions est vraie :
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.
Ce tableau présente les types de renvoi possibles pour les méthodes utilisant les annotations @Call, @Select, et @Update.
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. |
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 | ✓ | ✓ |
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.
int tCount = myGenericMethod( int.class );
où la définition de myGenericMethod est :<T> T myGenericMethod( Class<T> cl );
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.
Un objet ResultSet de base de données sous-jacent est fermé.
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.
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é.
Un objet ResultSet de base de données sous-jacent est fermé.
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é.
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.
Spécifie qu'un objet Iterator est renvoyé, 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.