Annotationen können auch Metadaten enthalten, die die Optionen steuern, die vom pureQuery-Dienstprogramm StaticBinder beim Durchführen einer Bindeoperation für die Schnittstelle genutzt werden.
@ColumnOverride(propertyName="extension", column="PHONE") public class EmployeeNewCo extends Employee {...
Eine Beschreibung der in den Syntaxdiagrammen verwendeten Konventionen finden Sie in Informationen zum Lesen von Syntaxdiagrammen.
>>-@ColumnOverride--(--propertyName--=--"--Eigenschaft--",--column--=--"--Name--")-><
>>-@ColumnOverrides--(------------------------------------------> .-,-------------------------------------------------------------------------------. V | >--{----@ColumnOverride--(--propertyName--=--"--Eigenschaft--",--column--=--"--Name--")-+--}--> >--)-----------------------------------------------------------><
Das Array mit den @ColumnOverride-Annotationen steht in geschweiften Klammern innerhalb der runden Klammern für die Annotation @ColumnOverrides.
>>-@Table--(--name--=--Tabellenname-----------------------------> >--+-----------------------------+--)-------------------------->< | (1) | '-------schema--=--Schemaname-'
Dies ist eine auf Klassenebene angegebene optionale Annotation, die einen Standardtabellennamen für alle Eigenschaften in den Beans angibt. Die Annotation ist nicht erforderlich, wenn Sie eine Gruppe verschachtelter Beans für SQL-Anweisungen mit Joins erstellen. Die Annotation vereinfacht jedoch die Definition von Beans.
Der Standardtabellenname kann durch einen Tabellennamen überschrieben werden, der in einer @Column-Annotation angegeben wird.
Die Annotation @Table gibt keinen Standardtabellennamen für @JoinColumn-Annotationen an.
Im Gegensatz zu @ColumnOverride und @ColumnOverrides in der integrierten Darstellung wird die Annotation @Table sowohl in der DAO-Darstellung als auch in der integrierten Darstellung von Unterklassen übernommen.
pureQuery erkennt Annotationen auf Eigenschaftenebene nur bei öffentlichen Feldern und bei den öffentlichen Methoden get() oder set(). Bei privaten oder geschützten Feldern werden diese Annotationen nicht erkannt.
Eine Beschreibung der in diesem Syntaxdiagramm verwendeten Konventionen finden Sie in Informationen zum Lesen von Syntaxdiagrammen.
Diese Annotation gibt die SQL-Spalte in einem Datenbankobjekt an, dem eine Eigenschaft zugeordnet ist. Sie können diese Annotation nur bei öffentlichen Feldern und Methoden verwenden. Wird sie anderweitig verwendet, wird sie von pureQuery ignoriert.>>-@Column--(--name--=--Spaltenname--+------------------------+->< '-table--=--Tabellenname-'
Sie können die Annotation @Column aus den folgenden beiden Gründen verwenden:
@Column(name="DEPTNO") public String deptNum;
@Column(name="EMPNO") public String getEmpNum() { return empNum; }
Beispiel
select a.col1, b.col1 from a, b where a.id=b.id;Die Methoden setA_col1 und setB_col1 für die entsprechenden Eigenschaften in den Beans, die die Abfrageergebnisse aufnehmen, benötigen @Column-Annotationen, die den Namen der Tabelle angeben, in der die beiden Spalten col1 auftreten:
public class JoinExample{ private int a_col1; private int b_col1; @Column (name="col1", table="a") public void setA_col1 (int a_col1) { this.a_col1 = a_col1; } public int getA_col1 () { return a_col1; } @Column (name="col1", table="b") public void setB_col1 (int b_col1) { this.b_col1 = b_col1; } public int getB_col1 () { return b_col1; } }
>>-@Format--(--fomatterClass--=--Formatierungsklasse------------> >--+---------------------------------------------+--)---------->< '-, -formattingOptions--=--Musterzeichenfolge-'
Diese Annotation gibt die Klasse an, die das Formatierungsprogramm, das für die Ausführung erforderlicher Konvertierungen aufgerufen wird, sowie die Formatierungsoptionen enthält. Sie können diese Annotation in einem Feld in einem Bean-Objekt verwenden, das als Eingabe oder Ausgabe für eine pureQuery-Methode angegeben ist. Dies gilt sowohl für die DAO-Darstellung als auch für die integrierte Darstellung.
Diese Formatierungsklasse konvertiert Zeichenfolgefelder in die korrekten JDBC-Typen für Datum/Uhrzeit für Eingabevariablen und konvertiert und formatiert die zurückgegebenen JDBC-Typen für die Ausgabe in Zeichenfolgevariablen.
Im folgenden Beispiel wird das Feld 'startDate' formatiert:
class MyBean { … @Format(formatter=com.ibm.pdq.Dateformatter.class, formattingOtions=”style=LONG; timezone=UTC”) String startDate; … }
Die Annotation gilt nicht für Java-Basiselementfelder, da Java-Basiselemente keinen Nullwert darstellen können.
Wenn die Annotation @Required nicht angegeben wird, werden Java-Nullwerte in Eingabeparametern standardmäßig erkannt und der Wert der entsprechenden Hostvariablen wird auf SQL NULL gesetzt.
Wenn die Annotation @Required in einem Feld angegeben wird, das als Eingabe für einen SQL-Parameter verwendet wird, und dieses Feld beim Zugriff auf das Feld einen Java-Nullwert enthält, wird von pureQuery eine Ausnahmebedingung ausgelöst und die SQL-Operation wird nicht versucht.
Beim folgenden Beispiel wird vorausgesetzt, dass der Wert 'customerAddress' einen Wert ungleich null enthalten muss.
@Required String customerAddress;
Bei einer SQL-Abfrage mit Tabellenjoins können Sie eine Gruppe verschachtelter Beans erstellen, die Daten aus der Abfrage zurückgeben. Die Hierarchie der Beans bildet die relationale Struktur der Tabellen und Daten in der Datenbank nach. Sie geben pureQuery-Annotationen mit verschachtelten Beans an, um die Tabellen- und Spaltenbeziehungen anzugeben. pureQuery Runtime füllt die Beans mit den Ergebnissen der Abfrage. Informationen zu verschachtelten Beans, die in Verbindung mit Tabellenjoins verwendet werden, finden Sie in Verschachtelte Beans und SQL-Abfragen mit Tabellenjoins.
Annotationen auf Eigenschaftenebene
>>-@Id---------------------------------------------------------><
Diese Annotation gibt an, dass die mit Annotationen versehene Eigenschaft eine Identitätsspalte darstellt, die von pureQuery Runtime verwendet wird, um die Gleichheit zwischen Beans derselben Klasse zu bestimmen. Diese Annotation wird für Eigenschaften einer Bean verwendet. Identitätsspalten sind Spalten, die die untergeordneten Beans mit der übergeordneten Bean verknüpfen. In der Bean der höchsten Ebene muss mindestens eine @Id-Annotation angegeben werden, um die Generierung verschachtelter Beans durch pureQuery Runtime zu ermöglichen. Die übereinstimmende Spalte in der Datenbank muss nicht als Primär- oder Fremdschlüsselspalte deklariert werden.
Die Annotation @Column kann in Verbindung mit der Annotation @Id verwendet werden, um den Spaltennamen und den Tabellennamen anzugeben, die das ResultSet-Objekt der Schlüsselspalte zuordnen.
In untergeordneten Beans kann entweder die Annotation @Id oder eine Annotation @JoinPoint verwendet werden, um Identitätsspalten zu definieren, die eine übergeordnete Bean mit einer untergeordneten Bean verknüpfen. Wenn beide angegeben sind, werden die Informationen aus der Annotation @JoinPoint verwendet und die Annotation @Id wird ignoriert. Die Annotation @JoinPoint wird in der übergeordneten Bean in einem Verweis auf die Bean angegeben. Die Annotation @Id wird dagegen in der Bean selbst angegeben.
Wenn die Bean einen Verbundschlüssel hat, müssen mehrere @Id-Annotationen in der untergeordneten Bean angegeben werden oder die Schlüssel müssen mit einer @JoinPoint-Annotation in der übergeordneten Bean angegeben werden. In der Annotation @JoinPoint muss ein Schlüssel durch eine Annotation @JoinColumn mit dem Element propertyName angegeben werden.
pureQuery Runtime prüft die Bean-Eigenschaften mit @Id-Annotationen, um bei der Verarbeitung verschachtelter Beans zu ermitteln, ob Beans gleich sind. Wenn alle Eigenschaften mit @Id-Annotationen gleich sind, werden die Beans als gleich betrachtet. Bean-Eigenschaft mit @Id-Annotationen müssen keine Primär- oder Fremdschlüssel in der Datenbank sein. Sie müssen jedoch ausreichen, um die Gleichheit zwischen Beans derselben Klasse zu bestimmen.
>>-@JoinColumn--(--name--=--Spaltenname-------------------------> >--+-----------------------+------------------------------------> '-table--=--Spaltenname-' >--+-----------------------------------+--)-------------------->< '-propertyName--=--Eigenschaftsname-'
Diese Annotation gibt eine Spalte eines ResultSet-Objekts als Identitätsspalte einer untergeordneten Bean an, wenn der Eigenschaftsname der übergeordneten Bean nicht der Spaltenkennung eines ResultSet-Objekts oder dem Tabellennamen entspricht. Diese Annotation wird in der übergeordneten Bean als Annotation für die untergeordneten Beans angegeben. Die untergeordneten Beans sind entweder eine einzelne Bean oder eine Liste von Beans.
Eine Annotation @JoinColumn kann nur in einer Annotation @JoinPoint angegeben werden.
Wenn Sie eine leere Zeichenfolge ("") als Wert für das Element name angeben, inaktiviert pureQuery Runtime die Unterstützung für die Generierung verschachtelter Beans für diese Eigenschaft, ohne eine Warnung zu generieren, dass die Eigenschaft nicht übereinstimmt. Sie können eine leere Zeichenfolge in einer Unterklasse angeben, wenn Sie nicht wollen, dass eine bestimmte untergeordnete Bean oder Liste von Beans gefüllt wird.
>>-@JoinPoint---------------------------------------------------> >--+-------------------------------------------------------------------------------------------+->< '-(--+----------------------------------------------------+--+-------------------------+--)-' '-+------------+--Array_von_@JoinColumn-Annotationen-' '-columnPrefix--=--Präfix-' +-joinCol--=-+ '-value--=---'
In der Bean der höchsten Ebene, d. h. der Bean, die der Rückgabewert der Methode oder integrierten API ist, muss mindestens eine @JoinPoint-Annotation angegeben werden. Die Annotation ermöglicht die Generierung einer Gruppe verschachtelter Beans durch pureQuery Runtime.
Die Annotation kann nur für eine Eigenschaft definiert werden, die eine Bean oder eine Liste von Beans enthält. Die optionalen @JoinColumn-Annotationen definieren die Spalten des ResultSet-Objekts, die den Identitätsspalten einer untergeordneten Bean zugeordnet werden. Das optionale Element columnPrefix gibt ein Spaltenpräfix an, das jeder Eigenschaft in der untergeordneten Bean hinzugefügt werden soll. Wenn die untergeordnete Bean einen Verbundschlüssel hat, müssen mehrere Spalten des ResultSet-Objekts als Schlüsselspalte angegeben werden.
Die Annotation kann nur für eine Eigenschaft definiert werden, die eine Bean oder eine Liste von Beans enthält. Wenn keines der optionalen Elemente (ein Array von @JoinColumn-Annotationen oder ein Element columnPrefix) angegeben ist, werden alle ResultSet-Zuordnungen und Identitätsspaltendefinitionen von der untergeordneten Bean übernommen.
Ein Array von @JoinColumn-Annotationen ist optional und bezieht sich auf die Eigenschaften der untergeordneten Bean. Arrays aus mehreren @JoinColumn-Annotationen müssen in geschweifte Klammern ({ }) eingeschlossen werden.
Wenn keine @JoinColumn-Annotationen angegeben sind, verwendet pureQuery Runtime die @Id-Annotationen der referenzierten untergeordneten Bean, um zu ermitteln, welche ResultSet-Spalten den Identitätsspalten der untergeordneten Bean zugeordnet werden. Wenn eine untergeordnete Bean nicht mindestens eine @Id-Annotation enthält, wird eine Warnung generiert und die untergeordnete Bean wird ignoriert.
Das Element joinCol und das Element value schließen sich gegenseitig aus. Nur eines der beiden kann angegeben werden, nicht jedoch beide zusammen. Das Element joinCol ist erforderlich, wenn das Element columnPrefix angegeben ist.
Der Wert des Elements columnPrefix gibt eine Zeichenfolge an, die jeder Eigenschaft in der untergeordneten Bean vorangestellt werden soll. Mit dem Präfix generiert pureQuery Runtime eindeutige Klassen und Eigenschaften. Das Präfix ermöglicht es, dass dieselbe Bean-Klasse in unterschiedlichen Ebenen oder in derselben Ebene einer verschachtelten Bean-Struktur ohne Rekursion verwendet wird. Stellen Sie sicher, dass diese Eigenschaften mit Präfix eindeutig sind. Sobald ein Präfix zu einer Klasse hinzugefügt wird, wird dieses Präfix auf alle untergeordneten Beans und die Eigenschaften der Beans der mit Präfix versehenen Klasse angewendet. Präfixe sind kumulativ. Die Verschachtelung kann beliebig tief fortgesetzt werden. Der Wert des Elements columnPrefix wird nur auf die untergeordnete Bean angewendet und nicht auf die in den @JoinColumn-Annotationen der übergeordneten Bean definierten Spaltenkennungen.
Spaltenpräfixe werden nur angewendet, wenn die Abfrage Spalten zurückgibt, die die untergeordnete Bean füllen.
@JoinPoint({ @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"), @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId") }) public List<Employee> getListofDeptEmployees ();
Die erste @JoinColumn-Annotation ordnet die Spalte DEPTNO aus der Tabelle DEPARTMENT der Eigenschaft empDepartment in der Bean 'Employee' zu.
Wenn Sie angegeben hätten, dass die Spaltenkennung WORKDEPT aus dem ResultSet-Objekt verwendet werden soll, müssten Sie das Element propertyName = "empDepartment" nicht angeben, wenn die Spaltenkennung WORKDEPT im ResultSet-Objekt vorhanden ist. Die Eigenschaft WORKDEPT wurde von der Annotation @Column (name = "WORKDEPT") in der Bean 'Employee' erstellt.
@JoinPoint(value = { @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"), @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId") }) public List<Employee> getListofDeptEmployees ();
@JoinPoint(columnPrefix = "DE", joinCol = { @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="empDepartment"), @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId") }) public List<Employee> getListofDeptEmployees ();
Ein Spaltenpräfix DE für Abteilungsmitarbeiter wird allen Eigenschaften der Bean 'Employee' vorangestellt und die Zeichenfolge DE würde (über die Klausel AS) allen Mitarbeiterspalten im ResultSet-Objekt hinzugefügt, die für die Abteilungsliste von Employee-Beans vorgesehen sind.
Das Präfix wird auch auf alle untergeordneten Beans in dieser Bean 'Employee' angewendet.
Wenn die Bean 'Employee' z. B. eine untergeordnete Bean 'Department' enthält, würde allen Eigenschaften der Bean 'Department' in dieser Bean 'Employee' die Zeichenfolge DE vorangestellt.
Das Voranstellen wird für alle im ResultSet-Objekt vorhandenen Ebenen fortgesetzt. Der zweiten Ebene der Liste von Employee-Beans in der untergeordneten Bean 'Department' würde DEDE vorangestellt.
Das Präfix wird auf alle untergeordneten Beans in dieser Bean 'Employee' angewendet, nicht jedoch auf alle Employee-Beans in der verschachtelten Bean-Struktur. Beispielsweise wird das Präfix nicht in der Liste von Employee-Beans in der Bean 'Project' verwendet.
@JoinPoint public List<Emp> emps; @JoinPoint(columnPrefix="m_") public Emp manager;
Durch Angabe des Elements columnPrefix="m_" werden die Spalten aus der Tabelle EMPLOYEE, denen m_ vorangestellt ist, dem Feld 'Emp manager' zugeordnet.
CREATE TABLE HRDEPT.EMPLOYEE( EMPNO CHAR(6) NOT NULL, FIRSTNME VARCHAR(12) NOT NULL, MIDINIT CHAR(1), LASTNAME VARCHAR(15), WORKDEPT CHAR(2), PHONENO CHAR(4), HIREDATE DATE, PRIMARY KEY(EMPNO))Einige der Spaltennamen sind abgekürzt oder entsprechen nicht den Java-Namenskonventionen.
Die folgende Definition für eine Bean 'Employee' verwendet @Column-Annotationen, um aussagekräftigere Namen für die Benutzer von Objekten der Klasse com.company.Employee bereitzustellen.
public class Employee { private String employeeId; private String firstName; private String middleInitial; private String lastName; private String departmentId; private String extension; private Date hireDate; @Column(name="EMPNO") public String getEmployeeId () { return employeeId; } public void setEmployeeId (String employeeId) { this.employeeId = employeeId; } @Column(name = "FIRSTNME") public String getFirstName () { return firstName; } public void setFirstName (String firstName) { this.firstName = firstName; } @Column(name = "MIDINIT") public String getMiddleInitial () { return middleInitial; } public void setMiddleInitial (String middleInitial) { this.middleInitial = middleInitial; } public String getLastName () { return lastName; } public void setLastName (String lastName) { this.lastName = lastName; } @Column(name = "WORKDEPT") public String getDepartmentId () { return departmentId; } public void setDepartmentId (String departmentId) { this.departmentId = departmentId; } @Column(name = "PHONENO") public String getExtension () { return extension; } public void setExtension (String extension) { this.extension = extension; } public Date getHireDate () { return hireDate; } public void setHireDate (Date hireDate) { this.hireDate = hireDate; } }
Wenn eine Anwendung für eine Datenbank mit leicht abweichendem Schema ausgeführt wird, wird die Tabelle wie folgt definiert:
CREATE TABLE HRDEPTNEWCO.EMPLOYEE( EMPNO CHAR(6) NOT NULL, FIRSTNME VARCHAR(12) NOT NULL, MIDINIT CHAR(1), LASTNAME VARCHAR(15), WORKDEPT CHAR(2), PHONE CHAR(4), HIREDATE DATE, PRIMARY KEY(EMPNO))
Sie können eine Unterklasse für die Bean 'Employee' erstellen, um die vorherige Annotation zu überschreiben, damit mit der neuen Tabellendefinition gearbeitet werden kann. Der Anfang der Unterklasse könnte wie dieses Beispiel aussehen:
@ColumnOverride(propertyName="extension", column="PHONE") public class EmployeeNewCo extends Employee {...
@Id @GeneratedKey @Column(name="EMPNO") public String getEmployeeId () { return employeeId; } public void setEmployeeId (String employeeId) { this.employeeId = employeeId; } @Id @Column(name = "WORKDEPT") public String getDepartmentId () { return departmentId; } public void setDepartmentId (String departmentId) { this.departmentId = departmentId; }
@JoinPoint({ @JoinColumn (name = "DEPTNO", table = "DEPARTMENT", propertyName="workDept"), @JoinColumn (name = "EMPNO", table = "EMPLOYEE", propertyName="employeeId") }) public List<Employee> getListofDeptEmployees ();
In der ersten Annotation @JoinColumn wird die Spalte DEPTNO aus der Tabelle DEPARTMENT der Eigenschaft 'workDept' in der Bean 'Employee' zugeordnet. Wenn die Spaltenkennung WORKDEPT aus dem ResultSet-Objekt verwendet worden wäre, wäre propertyName="workDept" nicht erforderlich, wenn die Spaltenkennung WORKDEPT im ResultSet-Objekt enthalten ist. Die Eigenschaft WORKDEPT wird von der Annotation @Column (name = "WORKDEPT") in der Bean 'Employee' erstellt.