Dziedziczenie i język EJB QL

Dziedziczenie i język EJB QL 1. Odwzorowanie hierarchii komponentów encyjnych SINGLE_TABLE, TABLE_PER_CLASS, JOINED. 2. Podstawy języka zapytań EJB QL interfejs Query, proste zapytania, relacje i złączenia, operatory IS EMPTY, MEMBER OF, podzapytania zapytania nazwane. 1

2 Komponenty encyjne a dziedziczenie Specyfikacja Java Persistence Api pozwala opisać dziedziczenie, polimorfizm, relacje oraz zapytania polimorficzne. JPA dopuszcza trzy sposoby odwzorowania hierarchii encji: - pojedyncza tabela dla całej hierarchii klas, - osobna tabela dla każdej klasy, - osobna tabela dla każdej podklasy.

Komponenty encyjne a dziedziczenie public class Person implements java.io.serializable{ private int id; private String firstname; private String lastname; public class Customer extends Person { private String street; private String city; private String state; private String zip; public class Employee extends Customer { private int employeeid; 3

4 Pojedyncza tabela Pojedyncza tabela odwzorowuje wszystkie klasy w ramach danej hierarchii. create table PERSON_HIERARCHY( id integer primary key not null, firstname varchar(255), lastname varchar(255), street varchar(255), city varchar(255), state varchar(255), zip varchar(255), employeeid integer, DISCRIMINATOR varchar(31) not null );

@Entity // domyślny dyskryminator: Employee nazwa komponentu public class Employee extends Customer { 5 Pojedyncza tabela @Entity @Table(name="PERSON_HIERARCHY") @Inheritance(strategy=InheritanceType.SINGLE_TABLE) @DiscriminatorColumn(name="DISCRIMINATOR", discriminatortype=discriminatortype.string) @DiscriminatorValue("PERSON") public class Person implements java.io.serializable{ @Entity @DiscriminatorValue("CUST") public class Customer extends Person {

6 Pojedyncza tabela <entity-mappings> <entity class="com.titan.domain.person"> <inheritance strategy="single_table"/> <discriminator-column name="discriminator" discriminator-type="string"/> <discriminator-value>person</discriminator-value> <attributes> <id> <generated-value/> </id> </attributes> </entity> <entity class="com.titan.domain.customer"> <discriminator-value>cust</discriminator-value> </entity> <entity class="com.titan.domain.employee"/> </entity-mappings>

7 Pojedyncza tabela Zalety: - prosta koncepcyjnie, - duża wydajność. Wady: - dużo pól o wartości NULL, - atrybuty klas potomnych muszą przyjmować wartości NULL, - brak postaci normalnej.

Osobne tabele dla klas create table Person ( id integer primary key not null, firstname varchar(255), lastname varchar(255), ); create table Customer ( id integer primary key not null, firstname varchar(255), ); lastname varchar(255), street varchar(255), city varchar(255), state varchar(255), zip varchar(255), create table Employee ( id integer primary key not null, firstname varchar(255), lastname varchar(255), street varchar(255), city varchar(255), state varchar(255), zip varchar(255), employeeid integer, ); 8

9 Osobne tabele dla klas @Entity @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) public class Person implements java.io.serializable{ @Entity public class Customer extends Person { @Entity public class Employee extends Customer {

10 Osobne tabele dla klas <entity-mappings> <entity class="com.titan.domain.person"> <inheritance strategy="table_per_class"/> <attributes> <id> <generated-value/> </id> </attributes> </entity> <entity class="com.titan.domain.customer"/> <entity class="com.titan.domain.employee"/> </entity-mappings>

Osobne tabele dla klas Zalety: - możliwość określenia dodatkowych warunków dla atrybutów (np. wartość domyślna), - prostsze odwzorowanie. Wady: - brak postaci normalnej, - redundancja, - niska wydajność: dużo dodatkowych operacji w celu odwzorowania relacji itp. Zwykle nie zaleca się stosowania tej strategii odwzorowania hierarchii klas. 11

Osobne tabele dla podklas create table Person ( id integer primary key not null, firstname varchar(255), lastname varchar(255), ); create table Customer ( id integer primary key not null, street varchar(255), city varchar(255), state varchar(255), zip varchar(255), ); create table Employee ( EMP_PK integer primary key not null, employeeid integer ); 12

13 Osobne tabele dla podklas @Entity @Inheritance(strategy=InheritanceType.JOINED) public class Person { @Entity public class Customer extends Person { @Entity @PrimaryKeyJoinColumn(name="EMP_PK") public class Employee extends Customer {

14 Osobne tabele dla podklas <entity-mappings> <entity class="com.titan.domain.person"> <inheritance strategy="joined"/> <attributes> <id> <generated-value/> </id> </attributes> </entity> <entity class="com.titan.domain.customer"/> <entity class="com.titan.domain.employee"> <primary-key-join-column name="emp_pk"/> </entity> </entity-mappings>

15 Osobne tabele dla podklas Zalety: - możliwość określenia dodatkowych warunków dla atrybutów (np. wartość domyślna), - prostsze odwzorowanie, - zwykle większa wydajność niż TABLE_FOR_CLASS, - model normalizowalny. Wady: - mniejsza wydajność niż SINGLE_TABLE.

@Entity @Table(name="EMPLOYEE") @PrimaryKeyJoinColumn(name="EMP_PK") public class Employee extends Customer { 16 Nieencyjne klasy bazowe @MappedSuperclass public class Person { @Id @GeneratedValue public int getid( ) { return id; @Entity @Table(name="CUSTOMER") @Inheritance(strategy=InheritanceType.JOINED) // atrybut lastname z nadklasy będzie odwzorowany w tabeli CUSTOMER // w pole SURNAME (domyślnie byłby w polu lastname) @AttributeOverride(name="lastName", column=@column(name="surname")) public class Customer extends Person {

Nieencyjne klasy bazowe <entity-mappings> <mapped-superclass class="com.titan.domain.person"> <attributes> <id> <generated-value/> </id> </attributes> </mapped-superclass> <entity class="com.titan.domain.customer"> <inheritance strategy="joined"/> <attribute-override name="lastname"> <column name="surname"/> </attribute-override> </entity> <entity class="com.titan.domain.employee"> <primary-key-join-column name="emp_pk"/> </entity> </entity-mappings> 17

18 Elementy EJB QL EJB QL jest deklaratywnym językiem zapytań służącym do przetwarzania obiektów Javy. Zapytania zapisane w języku EJB QL są tłumaczone przez kontener komponentów na jedno lub kilka zapytań SQL, które są kierowane do bazy danych poprzez interfejs JDBC. Język EJB QL nie zawsze jest wystarczającym narzędziem jednak jego stosowanie gwarantuje przenośność

19 Elementy EJB QL try { Query query = entitymanager.creatquery( "from Customer c where c.firstname='bill' and c.lastname='burke'"); Customer cust = (Customer)query.getSingleResult( ); catch (EntityNotFoundException notfound) { catch (NonUniqueResultException nonunique){ Wykonywanie zapytań odbywa się za pomocą interfejsu Query, który nieco przypomina, stosowany w JDBC interfejs java.sql.preparedstatement. Odbieranie wyników zapytania jest możliwe poprzez dwie metody: public List getresultlist( ); public Object getsingleresult( );

20 Interfejs Query - parametry Parametry pełnią identyczną rolę jak w przypadku PreparedStatement mogą być nazywane (zalecane): Query query = entitymanager.createquery( "from Customer c where c.firstname=:first and c.lastname=:last"); query.setparameter("first", first); query.setparameter("last", last); java.util.list list = query.getresultlist( ); oraz numerowane: Query query = entitymanager.createquery( "from Customer c where c.firstname=?1 and c.lastname=?2"); query.setparameter(1, first); query.setparameter(2, last); query.getresultlist( );

21 Proste zapytania SELECT OBJECT( c ) FROM Customer AS c SELECT c FROM Customer AS c SELECT c FROM Customer c Jeśli klauzula SELECT obejmuje więcej niż jedną kolumnę pojedynczym wynikiem jest tablica Object[]. Query query = manager.createquery( "SELECT c.firstname, c.lastname FROM Customer AS c"); List results = query.getresultlist( ); Iterator it = results.iterator( ); while (it.hasnext( )) { Object[] result = (Object[])it.next( ); String first = (String)result[0]; String last = (String)result[1];

22 Proste zapytania public class Name { private String first; private String last; public Name(String first, String last) { this.first = first; this.last = last; SELECT new Name(c.firstName, c.lastname) FROM Customer c W wyniku zapytania zostanie zwrócony obiekt Name lub ich lista.

Zapytania a relacje 1:1 N:1 1:1 Customer CreditCard CreditCompany Address SELECT c.creditcard.creditcompany.address.city FROM Customer AS c @Entity public class Address { private ZipCode zip; public class ZipCode implements java.io.serializable { public int maincode, codesuffix; SELECT c.address.zip.maincode FROM Customer AS c // źle @Entity public class Address { @Embedded private ZipCode zip; SELECT c.address.zip.maincode FROM Customer AS c // dobrze 23

24 Zapytania a relacje (JOIN) Customer N:N Reservation N:1 Cruise N:1 N:1 Ship SELECT c.reservations.cruise FROM Customer AS c customer.getreservations().getcruise(); // źle EJB QL // źle Java SELECT r.cruise FROM Customer AS c, IN( c.reservations ) r SELECT r.cruise FROM Customer c INNER JOIN c.reservations r SELECT r.cruise FROM Customer c JOIN c.reservations r SELECT cb.ship FROM Customer c JOIN c.reservations r JOIN r.cabins cb

25 Zapytania a relacje (LEFT JOIN) Customer 1:N Phone SELECT c.firstname, c.lastname, p.number FROM Customer c LEFT JOIN c.phones p Adam Kot (12)654 32 11 Julia Zielińska (17)908 23 44 Julia Zielińska 0 690 579 870 Aneta Czarnecka null SELECT c.firstname, c.lastname, p.number FROM Customer c LEFT OUTER JOIN c.phones p SELECT c.firstname, c.lastname, p.number FROM Customer c LEFT JOIN FETCH c.phones p

26 Klauzula WHERE: operator IS EMPTY Podobnie jak w języku SQL, klauzula WHERE obsługuje porównania, operacje arytmetyczne, logiczne oraz operatory IN, BETWEEN, LIKE, IS NULL. Inne operatory: IS EMPTY // rejsy bez rezerwacji: SELECT crs FROM Cruise AS crs WHERE crs.reservations IS EMPTY // rejsy z co najmniej jedną rezerwacją: SELECT crs FROM Cruise AS crs WHERE crs.reservations IS NOT EMPTY // niepoprawne zbiór wynikowy: rozpatrywane są tylko rezerwacje z niepustymi customers ze względu na wcześniejsze złączenie. SELECT r FROM Reservation AS r INNER JOIN r.customers AS c WHERE r.customers IS NOT EMPTY AND c.address.city = 'Boston'

27 Klauzula WHERE operator MEMBER OF // lista rejsów dla których dany klient dokonał rezerwacji: SELECT crs FROM Cruise AS crs, IN (crs.reservations) AS res, Customer AS cust WHERE cust = :mycustomer AND cust MEMBER OF res.customers // lista rejsów dla których dany klient nie dokonał rezerwacji: SELECT crs FROM Cruise AS crs, IN (crs.reservations) AS res, Customer AS cust WHERE cust = :mycustomer AND cust NOT MEMBER OF res.customers Jeśli sprawdzamy, czy encja jest składową kolekcji pustej otrzymamy wartość false. EJB QL umożliwia stosowanie podstawowych funkcji i operacji agregujących. Można także używać klauzul DISTINCT, ORDER BY, GROUP BY oraz HAVING.

28 Podzapytania // liczba rezerwacji o wartości większej niż wartość średnia SELECT COUNT(res) FROM Reservation res WHERE res.amountpaid > (SELECT avg(r.amountpaid) FROM Reservation r) // rejsy z zapłaconymi wszystkimi rezerwacjami SELECT cr FROM Cruise cr WHERE 0 < ALL (SELECT res.amountpaid FROM cr.reservations res) // rejsy z co najmniej jedną nie zapłaconą rezerwacją ANY <-> SOME SELECT cr FROM Cruise cr WHERE 0 = ANY (SELECT res.amountpaid from cr.reservations res);

<entity-mappings> <named-query name="findfullypaidcruises"> <query> FROM Cruise cr WHERE 0 < ALL ( SELECT res.amountpaid from cr.reservations res) </query> </named-query> </entity-mappings> 29 Zapytania nazwane @NamedQueries({ @NamedQuery(name="findFullyPaidCruises", query= "FROM Cruise cr WHERE 0 < ALL ( SELECT res.amountpaid from cr.reservations res)") ) @Entity public class Cruise { // wywołanie zapytania Query query = em.createnamedquery("findfullypaidcruises");

30 Inne operacje Interfejs Query umożliwia także wykonywanie zbiorowej aktualizacji i usuwania rekordów (UPDATE, DELETE) za pośrednictwem metody executeupdate(). Istnieje także możliwość bezpośredniego wywołania zapytań SQL oraz zapytań nazwanych SQL.

31 Podsumowanie Specyfikacja JPA umożliwia elastyczne odwzorowanie obiektów Javy do relacyjnego modelu danych. Do podstawowych cech takiego odwzorowania dodano możliwość dziedziczenia komponentów encyjnych oraz określono funkcjonalny, zapewniający przenośność obiektowy język zapytań.