Syntax von mit Annotationen versehenen Methoden, die SQL für Datenbanken ausführen

Die Syntax der Deklarationen von mit Annotationen versehenen Methoden finden Sie in den folgenden Diagrammen.

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.

Syntax für die Ausführung von SQL-DML-Anweisungen ohne Cursor und von DDL-Anweisungen

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.

Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@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);

Syntax für die Ausführung von CALL-Anweisungen

Verwenden Sie diese Syntax für das Deklarieren von mit Annotationen versehenen Methoden, die CALL-Anweisungen ausführen.

Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@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);

Syntax für die Ausführung von SELECT-Anweisungen

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.

Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@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-+-'       

Anmerkungen:
  1. Innerhalb einer Annotation @Cursor können Sie eine Option nur ein Mal verwenden.

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 ();

Syntax für positionierte Aktualisierungen und Löschvorgänge

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

Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@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-+-'       

Anmerkungen:
  1. Innerhalb einer Annotation @Cursor können Sie diese Optionen nur ein Mal verwenden.

Syntax der Methode, die eine Anweisung UPDATE oder DELETE ausführt, die den benannten Cursor verwendet

Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@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);
Achtung: Schließen Sie keine Klausel WHERE in die Anweisung UPDATE oder DELETE ein. Tun Sie dies dennoch, protokolliert pureQuery bei der Erstellung einer Implementierung Ihrer Schnittstelle einen Fehler, sofern Sie die Optionen für Protokollierung vor der Ausführung dieses Dienstprogramms konfigurieren. pureQuery fügt der Anweisung eine Klausel WHERE CURRENT OF hinzu.

Beschreibungen der Syntaxelemente

@Call
Gibt an, dass die Methode eine SQL-Anweisung CALL ausführt.
sql
Gibt die für die Methode auszuführende Anweisung CALL an.
@Cursor
Gibt die Attribute des Cursors für eine Anweisung SELECT an. Sie können diese Annotation nur verwenden, wenn sie auch die Annotation @Select verwenden.
allowStaticRowsetCursors
Gibt an, ob der einer Anweisung SELECT zugeordnete Cursor beim statischen Ausführen der Anweisung ein Zeilengruppencursor ist, wenn Sie eine Datenquelle der DB2 Universal Database for z/OS Version 8 (neuer Funktionsmodus) oder der DB2 Version 9.1 for z/OS und den IBM® Data Server Driver für JDBC und SQLJ zum Herstellen der Verbindung zu dieser Datenquelle verwenden.
false
Gibt an, dass der einer Anweisung SELECT zugeordnete Cursor kein Zeilengruppencursor ist, wenn die Anweisung statisch ausgeführt wird.
Dies ist der Standardwert.
true
Gibt an, dass der einer Anweisung SELECT zugeordnete Cursor ein Zeilengruppencursor ist, wenn die Anweisung statisch ausgeführt wird. Wenn Sie den Wert auf true setzen, müssen Sie die folgenden Einschränkungen beachten:
  • Die SQL-Anweisung, die einen Zeilengruppencursor verwenden können soll, ist eine Anweisung SELECT, die Sie in einer Annotation @Select für die Methode angeben.
  • Der Rückgabetyp für die mit Annotationen versehene Methode weist pureQuery nicht an, nur eine Zeile in der Datenbank auszuwählen.
  • Keine der Spalten in Abfrageergebnissen hat den Datentyp LOB oder XML.
  • Der Cursor, den die Anweisung öffnet, ist schreibgeschützt. Wenn ein statischer Aktualisierungscursor Zeilengruppen verwendet, sind die Ergebnisse unvorhersehbar.

    pureQuery betrachtet eine Anweisung als aktualisierbar, wenn eine der folgenden Bedingungen vorliegt:

    • Das Attribut für gemeinsamen Zugriff ist nicht auf java.sql.ResultSet.CONCUR_UPDATABLE gesetzt.
    • Die SQL-Anweisung enthält nicht die Klausel FOR UPDATE.
    pureQuery betrachtet eine Anweisung als schreibgeschützt, wenn die Anweisung nicht aktualisierbar ist.
  • Die mit Annotationen versehene Methode wird nie durch eine gespeicherte Java-Prozedur aufgerufen.
concurrency
java.sql.ResultSet.CONCUR_READ_ONLY
Die ganzzahlige Konstante, die angibt, dass der Cursor Aktualisierungen verhindert, während das Abfrageergebnis geöffnet ist.
java.sql.ResultSet.CONCUR_UPDATABLE
Die ganzzahlige Konstante, die angibt, dass der Cursor Aktualisierungen zulässt, während das Abfrageergebnis geöffnet ist.
cursorName
Gibt den Namen eines Cursors an, der für positionierte Aktualisierungen und Löschvorgänge verwendet werden soll. Der Name darf nicht mit DB2JCCCURSOR oder DB_PDQ beginnen. Der Name muss auch die Regeln für die Benennung von Cursorn für Ihre Datenbank erfüllen.
holdability
java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT
Die ganzzahlige Konstante, die angibt, dass der Cursor am Ende einer Transaktion geschlossen wird.
java.sql.ResultSet.HOLD_CURSORS_OVER_COMMIT
Die ganzzahlige Konstante, die angibt, dass der Cursor am Ende einer Transaktion geöffnet bleibt.
type
java.sql.ResultSet.TYPE_FORWARD_ONLY
Die ganzzahlige Konstante, die angibt, dass der Cursor nur vorwärts bewegt werden kann.
java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE
Die ganzzahlige Konstante, die angibt, dass der Cursor vorwärts und rückwärts bewegt werden kann. Das Abfrageergebnis stellt eine Momentaufnahme der Daten dar.
java.sql.ResultSet.TYPE_SCROLL_SENSITIVE
Die ganzzahlige Konstante, die angibt, dass der Cursor vorwärts und rückwärts bewegt werden kann. Das Abfrageergebnis spiegelt Änderungen wider, die an den Daten vorgenommen werden, während der Cursor gehalten wird.
@Handler
Weist pureQuery an, beim Ausführen der mit Annotationen versehenen Methode anstatt der Standardprozedur von pureQuery eine bereitgestellte Implementierungsklasse zu verwenden.
callHandlerWithParameters
Gibt eine Implementierung der Schnittstelle com.ibm.pdq.handlers.CallHandlerWithParameters<CAL> an. Wenn Sie dieses Attribut angeben, verwendet pureQuery die Klasse zum Verarbeiten der Ergebnisse einer gespeicherten SQL-Prozedur CALL und zum Erstellen des Objekts, das von der mit Annotationen versehenen Methode zurückgegeben wird. Die Methode handleCall() der Klasse verarbeitet die Ergebnisse der gespeicherten SQL-Prozedur CALL und gibt ein Objekt des Typs <CAL> zurück, das die Ergebnisse beschreibt.
parameterHandler
Gibt eine Implementierung der Schnittstelle com.ibm.pdq.handlers.ParameterHandler an. Wenn Sie dieses Attribut angeben, verwendet pureQuery die Klasse, um die Parameterwerte für das Objekt java.sql.PreparedStatement für die SQL-Anweisung festzulegen.
Wenn die mit Annotationen versehene Methode eine gespeicherte Prozedur aufruft, muss ParameterHandler alle OUT- und INOUT-Parameter registrieren.
resultHandler
Gibt eine Implementierung der Schnittstelle com.ibm.pdq.handlers.ResultHandler<RES> an. Wenn Sie dieses Attribut angeben, verwendet pureQuery die Klasse zum Erstellen des Objekts, das von der mit Annotationen versehenen Methode zurückgegeben wird. Die Methode handle() der Klasse verarbeitet java.sql.ResultSet für eine SQL-Anweisung und gibt den Inhalt in einem Objekt des Typs <RES> zurück.
rowHandler
Gibt eine Implementierung der Schnittstelle com.ibm.pdq.handlers.RowHandler<ROW> an. Wenn Sie dieses Attribut angeben, verwendet pureQuery die Klasse zum Erstellen des Objekts, das jede Zeile der Abfrageergebnisse darstellt, die von der mit Annotationen versehenen Methode zurückgegeben werden. Diese Methode handle() der Klasse verarbeitet eine Zeile aus java.sql.ResultSet für eine SQL-Anweisung und gibt den Inhalt in einem Objekt des Typs <ROW> zurück.
@Select
Gibt an, dass die Methode eine SQL-Anweisung SELECT ausführt.
sql
Gibt die für die Methode auszuführende Anweisung SELECT an.
@Update
Gibt an, dass die Methode eine SQL-DML- oder SQL-DDL-Anweisung ausführt.
sql
Gibt die für die Methode auszuführende SQL-Anweisung an.
positionedCursorName
Gibt den Namen eines Cursors an, der für positionierte Aktualisierungen und Löschvorgänge verwendet werden soll. Der Name muss im Attribut cursorName der Annotation @Select definiert sein.
Wenn Sie eine Implementierung der Schnittstelle generieren, die die Methode deklariert, die dieses Attribut verwendet, fügt pureQuery der Anweisung UPDATE oder DELETE die erforderliche Klausel WHERE CURRENT OF hinzu.
Name_der_Methode
Gibt den Namen der Schnittstellenmethode an.
Parametertyp Parametername

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.

Rückgabetyp
Gibt den Rückgabetyp der Methode an.

In der folgenden Tabelle werden die Rückgabetypen angezeigt, die für Methoden möglich sind, die die Annotationen @Call, @Select und @Update verwenden.

Tabelle 1. Schlüssel zur Tabelle der Rückgabetypen
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.
Tabelle 2. Rückgabetypen nach Typ der Annotation
    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  
Anmerkung: Wenn Sie eine gespeicherte Prozedur verwenden, die mehrere ResultSet-Objekte zurückgibt, und wenn Sie alle diese Objekte verwenden wollen, verwenden Sie den Rückgabetyp StoredProcedureResult oder eine Implementierung der Schnittstelle CallHanderWithParameters<CAL>. Alle anderen Rückgabetypen, die Sie mit der Annotation @Call verwenden können, geben nur das erste ResultSet-Objekt von einem Aufruf einer gespeicherten Prozedur zurück.

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.

Java lässt z. B. keine Methodenaufrufe wie die folgenden zu:
int tCount = myGenericMethod( int.class );
, wobei Folgendes die Definition von myGenericMethod ist:
<T> T myGenericMethod( Class<T> cl );
Die deklarierte Klasse von tCount muss Integer sein.
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.

void
Gibt an, dass die Methode nichts zurückgibt.
java.sql.ResultSet
Gibt an, dass ein Objekt ResultSet zurückgegeben wird. Das Objekt ResultSet ist schreibgeschützt.
StoredProcedureResult
StoredProcedureResult ist nur als Rückgabetyp für eine mit Annotationen versehene Methode @Call, von der eine Anweisung CALL aufgerufen wird, zulässig. Nach der Ausführung der Methode können mithilfe des Objekts StoredProcedureResult mehrere von der gespeicherten Routine zurückgegebene Abfrageergebnisse verarbeitet werden oder es kann auf Ausgabeparameter zugegriffen werden.
int
Gibt an, dass die Methode eine Anzahl aktualisierter Zeilen zurückgibt.
int[]
Gibt an, dass die Methode ein Array mit ganzen Zahlen zurückgibt. Jedes Element im Array erfasst den Aktualisierungszähler für eine einzelne Ausführung der SQL-DML-Anweisung. Verwenden Sie diesen Rückgabetyp für Aktualisierungen im Stapelbetrieb.
List<Map<String,Object>>
Gibt an, dass die Methode eine Liste von Map<String,Object>-Objekten zurückgibt.
Details finden Sie in der Beschreibung der zurückgegebenen Map<String,Object>-Objekte.

Jedes zugrunde liegende Datenbankobjekt ResultSet wird geschlossen.

List<T>
Gibt an, dass ein Objekt List des Typs T zurückgegeben wird. Wenn die angegebene SQL-Anweisung eine Abfrage ist, entspricht jedes Element einer Zeile des Abfrageergebnisses.

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.

Alle Zeilen des Abfrageergebnisses werden gespeichert, wenn die Methode aufgerufen wird, und jedes zugrunde liegende Datenbankobjekt ResultSet wird geschlossen.
Map<String,Object>
Gibt an, dass ein Objekt Map<String,Object> erstellt und zurückgegeben wird. Die Kennungen der Rückkehrspalten des Abfrageergebnisses werden zu den Schlüsseln der Map. Die Spaltenkennungen werden in Kleinbuchstaben umgesetzt, um eine höhere Übereinstimmung mit der allgemeinen Java-Codedarstellung zu erreichen. Die entsprechenden Spaltenwerte aus einer Zeile des Abfrageergebnisses nehmen die Werte des Objekts Map an. Wenn mehrere Zeilen zutreffen, wird der Wert aus der ersten Zeile zurückgegeben.

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.

Map<String,Object>[]
Gibt an, dass ein Array von Map<String,Object>-Objekten erstellt und zurückgegeben werden. Siehe die Beschreibung der zurückgegebenen Map<String,Object>-Objekte.

Jedes zugrunde liegende Datenbankobjekt ResultSet wird geschlossen.

<T>

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.

<T>[]
Gibt an, dass ein Array des Typs T zurückgegeben wird, wie z. B. Employee[], Integer[] oder String[].
  • Wenn die angegebene SQL-Anweisung eine Abfrage ist, entspricht jedes Element einer Zeile des Abfrageergebnisses.
  • 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 die angegebene SQL-Anweisung keine Abfrage oder Anweisung CALL ist, die ResultSet zurückgibt, muss jedes Element des Arrays eine int-Instanz sein, die auf den zurückgegebenen Aktualisierungszähler der Anweisungen gesetzt ist.
Alle Zeilen des Abfrageergebnisses werden gespeichert, wenn die Methode aufgerufen wird, und jedes zugrunde liegende Datenbankobjekt ResultSet wird geschlossen.
Iterator<Map<String,Object>>

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.

Iterator<T>

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.

sql
Gibt die SQL-Anweisung an, die ausgeführt werden soll, wenn die zugeordnete Methode aufgerufen wird. Die SQL-Anweisung muss für die Zieldatenbank gültig sein. pureQuery definiert außerdem eine Anzahl von Parametermarken. Diese Marken entsprechen Eingabeparametern in integrierten oder in mit Annotationen versehenen Methoden.
Bei einigen JDBC-Treibern müssen Sie die JDBC/ODBC-Escapezeichenfolge verwenden, wenn Sie eine Anweisung CALL ausführen wollen.

Feedback