Syntax von mit Annotationen versehenen Methoden für Abfragen in speicherinternen Java-Objektgruppen

Wenn Sie mit Annotationen versehene Methoden zum Abfragen von speicherinternen Objektgruppen verwenden, müssen die Definitionen dieser Methoden die folgende Syntax befolgen.
Syntaxdiagramm lesenSyntaxdiagramm überspringen
>>-@Select--(--sql--=--"--SQL-Anweisung--"--)------------------->

>--+----------------------------------------------------------------------------------------+-->
   '-@Handler--(--+-parameterHandler--=--Klassenname-----------------------------------+--)-'   
                  +-resultHandler--=--Klassenname--------------------------------------+        
                  +-resultHandler--=--Klassenname--,--parameterHandler--=--Klassenname-+        
                  +-rowHandler--=--Klassenname-----------------------------------------+        
                  '-rowHandler--=--Klassenname--,--parameterHandler--=--Klassenname----'        

>--Modifikatoren--Rückgabetyp--Name_der_Methode--(--+---------------------------------+--);-><
                                                    | .-,---------------------------. |       
                                                    | V                             | |       
                                                    '---Parametertyp--Parametername-+-'       

Eine Beschreibung der in diesem Syntaxdiagramm verwendeten Konventionen finden Sie in Informationen zum Lesen von Syntaxdiagrammen.

Syntaxdiagramm lesenSyntaxdiagramm überspringen
Rückgabetyp:

>>-+-Iterator<T>--------+--------------------------------------><
   +-List<T>------------+   
   +-Map<String,Object>-+   
   +-T------------------+   
   '-T[]----------------'   

@Select
Gibt an, dass die Methode eine SQL-Anweisung SELECT ausführt. Diese Java™-Annotation gibt an, dass die entsprechende Methode eine pureQuery-Methode ist. Der pureQuery-Generator verarbeitet die Schnittstelle, um eine Implementierung für die Methode zu generieren.
sql
Gibt die SQL-Anweisung an, die ausgeführt werden soll, wenn die zugeordnete Methode aufgerufen wird. Abgesehen von der hinzugefügten Funktion, die auf eine Objektgruppe in der Klausel FROM verweist, muss die Syntax der SQL92-Standardsyntax entsprechen. pureQuery definiert außerdem eine Anzahl von Parametermarken. Diese Marken entsprechen Eingabeparametern in integrierten oder in mit Annotationen versehenen Methoden.
@Handler
Weist pureQuery an, beim Ausführen der mit Annotationen versehenen Methode anstatt der Standardprozedur von pureQuery eine bereitgestellte Implementierungsklasse zu verwenden.
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.
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.
Rückgabetyp
Gibt den Rückgabetyp der Methode an.

In der zweiten Tabelle werden die möglichen Rückgabetypen für mit Annotationen versehene Methoden angezeigt, die speicherinterne Objektgruppen abfragen.

Tabelle 1. Schlüssel zur Tabelle der Rückgabetypen
Abkürzung Bedeutung
I Iterator
L List
M Map
O Object
S String
T Generische Klasse, die eine Wrapperklasse für einen Java-Basiselementtyp oder eine Bean sein kann
Tabelle 2. Rückgabetypen nach Typ der Annotation
  I<M<S,O>> I<T> L<M<S,O>> L<T> M<S,O> M<S,O>[] <T>
@Select X X X X X X X

Wenn Sie eine mit Annotationen versehene Methode verwenden, geben Sie nicht an, dass @Select 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 );
Iterator<T>

Gibt an, dass ein Objekt Iterator zurückgegeben wird, wobei jedes Element einer Zeile entspricht. Der parametrisierte Typ T muss angegeben werden.

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.

List<T>
Gibt an, dass ein Objekt List des Typs T zurückgegeben wird. Jedes Element entspricht einer Zeile des Abfrageergebnisses.
Map<String,Object>
Gibt an, dass ein Objekt Map erstellt und zurückgegeben wird. Die Kennungen der Rückkehrspalten der SQL-Anweisung 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.
<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 mehrere Zeilen als Ergebnis der Abfrage zutreffen, wird der Wert aus der ersten Zeile zurückgegeben.

<T>[]
Gibt an, dass ein Array des Typs T zurückgegeben wird, wie z. B. Employee[], Integer[] oder String[]. Jedes Element entspricht einer Zeile des Abfrageergebnisses.
Name_der_Methode
Gibt den Namen der Schnittstellenmethode an.
Parametertyp Parametername

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 vom Bean- oder Map-Objekt werden für den Abgleich mit den Vorkommen von :Name in der SQL-Zeichenfolge verwendet.

Mindestens ein Parameter, der ein Iterator, ein Array oder eine iterierbare Liste ist, ist erforderlich, damit pureQuery die entsprechende Anweisung SELECT als Abfrage für eine speicherinterne Objektgruppe angeben kann. Referenzieren Sie diesen Parameter in der Klausel FROM der Anweisung SELECT, indem Sie die Syntax verwenden, die in Parametermarken in Klausel FROM von Abfragen über speicherinterne Java-Objektgruppen beschrieben ist.

Wenn das SQL die Notation mit ? für Parametermarken verwendet, können Sie nur skalare Werte angeben.

Wenn Sie die Notation ?n verwenden, müssen die entsprechenden Parameter Skalartypen sein (außer sie befinden sich in der Klausel FROM; in diesem Fall müssen sie Objektgruppen oder Array-Objekte sein).

Wenn Sie die Notation ?n.Name verwenden, müssen die entsprechenden Parameter Bean-Klassen oder Map-Objekte sein. Die Notationen ?n und ?n.Name können in einer einzelnen Abfrage gemischt sein, können aber nicht mit eigenständigen Parametermarken ? gemischt werden.


Feedback