Die Syntaxdiagramme und Beschreibungen der Syntaxelemente finden Sie in den folgenden Abschnitten.
Eine Beschreibung der in den Syntaxdiagrammen verwendeten Konventionen finden Sie in Informationen zum Lesen von Syntaxdiagrammen.
Verwenden Sie diese Syntax für das Deklarieren von mit Annotationen versehenen Methoden, die DML-Anweisungen ausführen, die keine Cursor verwenden. Sie können diese Syntax auch zum Ausführen von DDL-Anweisungen verwenden.
>>-@Update--(--sql--=--"--SQL-Anweisung--"--)-------------------> >--+--------------------------------------------------------------------------------------------+--> '-@Handler--(--+-parameterHandler--=--Klassenname---------------------------------------+--)-' +-resultHandler--=--Klassenname--+-------------------------------------+-+ | '-,--parameterHandler--=--Klassenname-' | '-rowHandler--=--Klassenname--+-------------------------------------+----' '-,--parameterHandler--=--Klassenname-' >--Modifikatoren--Rückgabetyp--Name_der_Methode--(--+----------------------+--+---------------------------------+--);->< '-Handler--Handlername-' | .-,---------------------------. | | V | | '---Parametertyp--Parametername-+-'
Beispiel
Es folgt ein Beispiel für die Syntax einer Methode, die eine Anweisung SELECT ausführt:
@Select(sql = "SELECT PID, QUANTITY, LOCATION FROM HEATHR.INVENTORY WHERE PID = ?") Inventory getInventory(String pid);
Es folgt ein Beispiel für die Syntax einer Methode, die eine Anweisung INSERT ausführt:
@Update(sql = "INSERT INTO HEATHR.INVENTORY (PID, QUANTITY, LOCATION) VALUES (?, ?, ?)") int createInventory(String pid, int quantity, String location);
Verwenden Sie diese Syntax für das Deklarieren von mit Annotationen versehenen Methoden, die CALL-Anweisungen ausführen.
>>-@Call--(--sql--=--"--SQL-Anweisung--"--)---------------------> >--+--------------------------------------------------------------------------------------------------------+--> '-@Handler--(--+-callHandlerWithParameters--=--Klassenname--+-------------------------------------+-+--)-' | '-,--parameterHandler--=--Klassenname-' | '-parameterHandler--=--Klassenname---------------------------------------------------' >--Modifikatoren--Rückgabetyp--Name_der_Methode--(--+----------------------+--+---------------------------------+--);->< '-Handler--Handlername-' | .-,---------------------------. | | V | | '---Parametertyp--Parametername-+-'
Beispiel
@Call(sql = "Call MYSCHEMA.BONUS_INCREASE( :p_bonusfactor, :p_bonusmaxsumfordept, :p_deptswithoutnewbonuses, :p_countdeptsviewed, :p_countdeptsbonuschanged, :p_errormsg )") StoredProcedureResult callBONUS_INCREASE(Bonus_increaseParam parms);
Verwenden Sie diese Syntax für das Deklarieren von mit Annotationen versehenen Methoden, die SELECT-Anweisungen ausführen. Wenn Sie die Annotation @Cursor verwenden, müssen Sie java.sql.ResultSet in Ihre Schnittstelle importieren.
>>-@Select--(--sql--=--"--SQL-Anweisung--"--)-------------------> >--+-----------------------------------------------------------------------------------------+--> | .-,-------------------------------------------------------------------. | | (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--=--Klassenname---------------------------------------+--)-' +-resultHandler--=--Klassenname--+-------------------------------------+-+ | '-,--parameterHandler--=--Klassenname-' | '-rowHandler--=--Klassenname--+-------------------------------------+----' '-,--parameterHandler--=--Klassenname-' >--Modifikatoren--Rückgabetyp--Name_der_Methode--(--+----------------------+--+---------------------------------+--);->< '-Handler--Handlername-' | .-,---------------------------. | | V | | '---Parametertyp--Parametername-+-'
Beispiel
@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 ();
Verwenden Sie diese Syntax, wenn Sie mit Annotationen versehene Methode für die Ausführung positionierter Aktualisierungen und Löschvorgänge deklarieren. Wenn Sie die Annotation @Cursor verwenden, müssen Sie java.sql.ResultSet in Ihre Schnittstelle importieren.
Informationen zum Schreiben von mit Annotationen versehenen Methoden für positionierte Aktualisierungen und Löschvorgänge finden Sie in Positionierte Aktualisierungen und Löschvorgänge ausführen.
Syntax der Methode, die die Anweisung SELECT ausführt, die einen Cursor für eine positionierte Aktualisierung oder einen positionierten Löschvorgang öffnet und benennt
>>-@Select--(--sql--=--"--SQL-Anweisung--"--)-------------------> >--+-----------------------------------------------------------------------------------------------------------------------------+--> | .-,-----------------------------------------------------------------------. | | V (1) .-java.sql.ResultSet.CONCUR_READ_ONLY-. | | '-@Cursor--(--cursorName--=--"--Cursorname--"--------+-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--=--Klassenname------------------------------------+--)-' '-rowHandler--=--Klassenname--+-------------------------------------+-' '-,--parameterHandler--=--Klassenname-' >--Modifikatoren--+-Iterator-----------+--Methodenname--(--+----------------------+--+---------------------------------+--);->< '-java.sql.ResultSet-' '-Handler--Handlername-' | .-,---------------------------. | | V | | '---Parametertyp--Parametername-+-'
Syntax der Methode, die eine Anweisung UPDATE oder DELETE ausführt, die den benannten Cursor verwendet
>>-@Update--(--sql--=--"--SQL-Anweisung--"--,--positionedCursorName--=--"--Cursorname--"--)--> >--+--------------------------------------------------+---------> '-@Handler--(--parameterHandler--=--Klassenname--)-' >--Modifikatoren--Rückgabetyp--Name_der_Methode--(--+----------------------+--+---------------------------------+--);->< '-Handler--Handlername-' | .-,---------------------------. | | V | | '---Parametertyp--Parametername-+-'
Beispiel
Es folgt ein Beispiel für die Syntax einer Methode, die eine Anweisung SELECT ausführt, die einen Cursor für positionierte Aktualisierungen und Löschvorgänge öffnet:
@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 ();
Es folgt ein Beispiel für die Syntax einer Methode, die eine Anweisung UPDATE ausführt, die den Cursor verwendet:
@Update (sql="update BOOKS SET PUBLISHER_ID = :publisher_id", positionedCursorName = "TESTCURSORITER") int updateBooksByUsingNamedCursor (Book b);
pureQuery betrachtet eine Anweisung als aktualisierbar, wenn eine der folgenden Bedingungen vorliegt:
Ein sich wiederholendes Argumentepaar, das die Typen und Namen der Argumente anzeigt, die zum Zeitpunkt des Methodenaufrufs erwartet werden.
Diese Parameter werden mit den in der SQL-Anweisung angegebenen Parametermarken entsprechend der nachstehenden Regeln abgeglichen. Diese Parameter können Skalartypen, Bean-Klassen oder Map-Objekte sein. Wenn das SQL die Notation :Name für Parameterverweise verwendet, muss der erste Parametertyp eine Bean oder Map sein. Die Eigenschaftsnamen von der Bean oder Map werden für den Abgleich mit den Vorkommen von :Name in der SQL-Zeichenfolge verwendet.
Wenn das SQL die Notation mit ? für Parameterverweise verwendet, können Sie nur skalare Werte angeben.
Wenn die Notation ?n und ?n.Name verwendet wird, müssen die Methodenparameter entweder alle Skalartypen oder eine Kombination aus Bean-Klassen und MAP-Objekten sein.
Die angegebenen Parameter werden normalerweise nur als Eingabevariablen verwendet. Im Fall von OUT- oder INOUT-Parametern in einer SQL-Anweisung CALL stellen Sie möglicherweise jedoch Ausgabevariablen dar. Weitere Details finden Sie im weiter oben angeordneten Abschnitt, in dem die Unterstützung für die Anweisung CALL erläutert wird.
In der folgenden Tabelle werden die Rückgabetypen angezeigt, die für Methoden möglich sind, die die Annotationen @Call, @Select und @Update verwenden.
Abkürzung | Bedeutung |
---|---|
CAL | CallHandlerWithParameters |
I | Iterator |
L | List |
M | Map |
O | Object |
R | java.sql.ResultSet |
RES | ResultHandler |
ROW | RowHandler |
S | String |
SPR | StoredProcedureResult |
T | Der primitive Datentyp int, eine Wrapperklasse für einen Java-Basiselementtyp, ein einfacher Typ Object oder eine Bean. T kann nur bei @Update-Annotationen int sein, und in @Update-Annotationen muss T int sein. |
Annotation | ||||
---|---|---|---|---|
@Call | @Select | @Update | ||
Rückgabetyp | 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>[] | ✓ | ✓ | ||
typenlos | ✓ | ✓ |
Wenn Sie eine mit Annotationen versehene Methode verwenden, geben Sie nicht an, dass @Select oder @Call einen Java-Basiselementtyp oder ein Array, eine Liste oder einen Iterator eines Java-Basiselementtyps zurückgibt.
Die Informationen hinsichtlich SQL-Nullwerten gehen verloren, wenn aus SQL abgefragte Informationen in einem Java-Basiselementtyp gespeichert werden. Außerdem erfordert Java, dass eine generische Methode, die eine generische Klasse <T> von <Java-Basiselementtyp>.class angibt, eine Instanz der Wrapperklasse zurückgeben muss, die für den Java-Basiselementtyp geeignet ist.
int tCount = myGenericMethod( int.class );, wobei Folgendes die Definition von myGenericMethod ist:
<T> T myGenericMethod( Class<T> cl );
Integer tCount = myQuery.myGenericMethod( Integer.class );
Diese Einschränkung ist mit der Verwendung von generischen Methoden verbunden, obwohl die Methodenkennungen, die in Ihrer mit Annotationen versehenen Schnittstelle definiert sind, keine explizite Verwendung von generischen Methodensignaturen (keine Verwendung von <T> und Rückgabeklasseninformationen) enthält. Diese Einschränkung ist notwendig, weil die generierte Implementierung einer mit Annotationen versehenen Schnittstelle Methoden verwendet, die den APIs der integrierten Methode in gewisser Hinsicht ähneln. Hervorzuheben ist, dass die Implementierung generische Methoden verwendet.
Jedes zugrunde liegende Datenbankobjekt ResultSet wird geschlossen.
Wenn ein Objekt <T> von einer CALL-Anweisung zurückgegeben wird, ist die Quelle der Daten, mit denen das Objekt gefüllt ist, das erste Objekt ResultSet, das die gespeicherte Prozedur zurückgibt.
Wenn ein Objekt <T> von einer SELECT-Anweisung zurückgegeben wird, ist die Quelle der Daten, mit denen das Objekt gefüllt ist, das Ergebnis der Abfrage.
Wenn ein Objekt Map<String,Object> von einer CALL-Anweisung zurückgegeben wird, ist die Quelle der Daten, mit denen das Objekt gefüllt ist, das erste Objekt ResultSet, das die gespeicherte Prozedur zurückgibt.
Wenn ein Objekt Map<String,Object> von einer SELECT-Anweisung zurückgegeben wird, ist die Quelle der Daten, mit denen das Objekt gefüllt ist, das Ergebnis der Abfrage.
Jedes zugrunde liegende Datenbankobjekt ResultSet wird geschlossen.
Jedes zugrunde liegende Datenbankobjekt ResultSet wird geschlossen.
Gibt an, dass ein Skalar oder eine Bean zurückgegeben wird. Ein Scalar könnte ein Wrapper wie z. B. Double sein oder ein Typ String (Zeichenfolge), Date (Datum) oder Timestamp (Zeitmarke).
Wenn die angegebene SQL-Anweisung eine Abfrage ist und mehrere Zeilen zutreffen, wird der Wert aus der ersten Zeile zurückgegeben.
Jedes zugrunde liegende Datenbankobjekt ResultSet wird geschlossen.
Gibt an, dass ein Iterator von Map<String,Object>-Objekten zurückgegeben wird. Details finden Sie in der Beschreibung der zurückgegebenen Map<String,Object>-Objekte.
Die Abfrageergebniszeilen werden aus der Datenquelle abgerufen, während die Anwendung jede Operation next() für den Iterator ausführt.
Iteratoren in pureQuery weisen den Typ ResultIterator auf. Sie müssen Iteratoren mit der Methode ResultIterator.close() schließen, wenn Sie sie nicht mehr verwenden.
Gibt an, dass ein Objekt Iterator zurückgegeben wird, wobei jedes Element einer Zeile entspricht. Der parametrisierte Typ T muss angegeben werden.
Die Abfrageergebniszeilen werden aus der Datenquelle abgerufen, während die Anwendung jede Operation next() für den Iterator ausführt.
Wenn ein Objekt <T> von einer CALL-Anweisung zurückgegeben wird, ist die Quelle der Daten, mit denen das Objekt gefüllt ist, das erste Objekt ResultSet, das die gespeicherte Prozedur zurückgibt.
Wenn ein Objekt <T> von einer SELECT-Anweisung zurückgegeben wird, ist die Quelle der Daten, mit denen das Objekt gefüllt ist, das Ergebnis der Abfrage.
Iteratoren in pureQuery weisen den Typ ResultIterator auf. Sie müssen Iteratoren mit der Methode ResultIterator.close() schließen, wenn Sie sie nicht mehr verwenden.