#033 Java EE 6 – JPA 2.0

package jpa20_helloworld;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

/**
*
* @author sang
*/
@Entity
public class Person {
@Id
@GeneratedValue
private int id;
private String name;
private long salary;

/**
* @return the id
*/
public int getId() {
return id;
}

/**
* @param id the id to set
*/
public void setId(int id) {
this.id = id;
}

/**
* @return the name
*/
public String getName() {
return name;
}

/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}

/**
* @return the salary
*/
public long getSalary() {
return salary;
}

/**
* @param salary the salary to set
*/
public void setSalary(long salary) {
this.salary = salary;
}

}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

/**
*
* @author sang
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Create EntityManager
EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“jpa2.0_helloworldPU”);
EntityManager em = emf.createEntityManager();

EntityTransaction tx = em.getTransaction();
tx.begin();

Person p1 = new Person();
p1.setName(“Sang Shin”);
p1.setSalary(10000);
em.persist(p1);

Person p2 = new Person();
p2.setName(“Annie Song”);
p2.setSalary(50000);
em.persist(p2);

tx.commit();

em.close();
emf.close();
}

}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;

public class JPAUtil {

// Database configuration
public static String url = “jdbc:derby://localhost:1527/sample”;
public static String dbdriver = “org.apache.derby.jdbc.ClientDriver”;
public static String username = “app”;
public static String password = “app”;
static Statement st;
static Connection conn;

static {
try {
Class.forName(dbdriver);
conn = DriverManager.getConnection(url, username, password);
st = conn.createStatement();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println(“Initial SessionFactory creation failed.” + ex);
throw new ExceptionInInitializerError(ex);
}
}

public static void setup(String sql) {
try {
createStatement();
st.executeUpdate(sql);
} catch (Exception e) {
System.err.println(“Got an exception! “);
e.printStackTrace();
System.exit(0);
}
}

public static void createStatement() {
try {
Class.forName(dbdriver);
conn = DriverManager.getConnection(url, username, password);
st = conn.createStatement();
} catch (Exception e) {
System.err.println(“Got an exception! “);
e.printStackTrace();
System.exit(0);
}
}

// Drop table if exists
public static void droptable(String sql) {
try {
createStatement();
st.executeUpdate(sql);
} catch (Exception e) {
}
}

public void executeSQLCommand(String sql) throws Exception {
st.executeUpdate(sql);
}

public static void checkData(String sql) {
String[] starray = sql.split(” “);
System.out.println(“\n******** Table: ” + starray[starray.length – 1] + ” *******”);
try {
createStatement();
ResultSet rs = st.executeQuery(sql);
outputResultSet(rs);
conn.close();
} catch (Exception e) {
e.printStackTrace();
}
}

public static void outputResultSet(ResultSet rs) throws Exception {
ResultSetMetaData metadata = rs.getMetaData();

int numcols = metadata.getColumnCount();
String[] labels = new String[numcols];
int[] colwidths = new int[numcols];
int[] colpos = new int[numcols];
int linewidth;

linewidth = 1;
for (int i = 0; i < numcols; i++) {
colpos[i] = linewidth;
labels[i] = metadata.getColumnLabel(i + 1); // get its label
int size = metadata.getColumnDisplaySize(i + 1);
if (size > 30 || size == -1) {
size = 30;
}
int labelsize = labels[i].length();
if (labelsize > size) {
size = labelsize;
}
colwidths[i] = size + 1; // save the column the size
linewidth += colwidths[i] + 2; // increment total size
}

StringBuffer divider = new StringBuffer(linewidth);
StringBuffer blankline = new StringBuffer(linewidth);
for (int i = 0; i < linewidth; i++) {
divider.insert(i, ‘-‘);
blankline.insert(i, ” “);
}
// Put special marks in the divider line at the column positions
for (int i = 0; i < numcols; i++) {
divider.setCharAt(colpos[i] – 1, ‘+’);
}
divider.setCharAt(linewidth – 1, ‘+’);

// Begin the table output with a divider line
System.out.println(divider);

// The next line of the table contains the column labels.
// Begin with a blank line, and put the column names and column
// divider characters “|” into it. overwrite() is defined below.
StringBuffer line = new StringBuffer(blankline.toString());
line.setCharAt(0, ‘|’);
for (int i = 0; i < numcols; i++) {
int pos = colpos[i] + 1 + (colwidths[i] – labels[i].length()) / 2;
overwrite(line, pos, labels[i]);
overwrite(line, colpos[i] + colwidths[i], ” |”);
}
System.out.println(line);
System.out.println(divider);

while (rs.next()) {
line = new StringBuffer(blankline.toString());
line.setCharAt(0, ‘|’);
for (int i = 0; i < numcols; i++) {
Object value = rs.getObject(i + 1);
if (value != null) {
overwrite(line, colpos[i] + 1, value.toString().trim());
overwrite(line, colpos[i] + colwidths[i], ” |”);
}
}
System.out.println(line);
}
System.out.println(divider);

}

static void overwrite(StringBuffer b, int pos, String s) {
int len = s.length();
for (int i = 0; i < len; i++) {
b.setCharAt(pos + i, s.charAt(i));
}
}
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import jpa20_helloworld.util.JPAUtil;

/**
*
* @author sang
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Create EntityManager
EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“jpa2.0_helloworldPU”);
EntityManager em = emf.createEntityManager();

EntityTransaction tx = em.getTransaction();
tx.begin();

Person p1 = new Person();
p1.setName(“Sang Shin”);
p1.setSalary(10000);
em.persist(p1);

Person p2 = new Person();
p2.setName(“Annie Song”);
p2.setSalary(50000);
em.persist(p2);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from PERSON”);

em.close();
emf.close();
}
}

import java.util.Set;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Employee {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int id;
private String name;
private long salary;

// Collection of basic type – String type in this case
@ElementCollection
// Name the table as “expertise”
@CollectionTable(name = “expertise”)
private Set<String> javaskills;

public Employee() {
}

public Employee(int id) {
this.id = id;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

@Override;
public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the javaskills
*/
public Set<String> geJavaskills() {
return javaskills;
}

/**
* @param javaskills the javaskills to set
*/
public void seJavaskills(Set<String> javaskills) {
this.javaskills = javaskills;
}
}

import examples.model.Employee;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.EmployeeService;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.EntityTransaction;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

// Create EntityManager
EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

// EmployeeService is a utility class
EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

Employee emp = es.createEmployee(“Sang Shin”, 10000);
Set<String> javaskills = new HashSet<String>();
javaskills.add(“servlet 3.0”);
javaskills.add(“ejb 3.1”);
javaskills.add(“jsf 2.0”);
javaskills.add(“jpa 2.0”);
es.setJavaskills(emp, javaskills);

emp = es.createEmployee(“Bill Clinton”, 8000);
javaskills = new HashSet<String>();
javaskills.add(“jsf”);
javaskills.add(“ejb”);
es.setJavaskills(emp, javaskills);

es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
es.createEmployee(“Charles Lannie”, 7500);
es.createEmployee(“Shelley Nichole”, 8500);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from EXPERTISE”);

em.close();
emf.close();

}
}

import java.util.Collection;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.Query;

public class EmployeeService {

protected EntityManager em;

public EmployeeService(EntityManager em) {
this.em = em;
}

public Employee createEmployee(String name, long salary) {
Employee emp = new Employee();
emp.setName(name);
emp.setSalary(salary);
em.persist(emp);
return emp;
}

public Employee updateEmployee(Employee emp) {
em.persist(emp);
return emp;
}

public void setJavaskills(Employee emp, Set<String> javaskills) {
if (emp != null) {
emp.seJavaskills(javaskills);
}
}

public void removeEmployee(int id) {
Employee emp = findEmployee(id);
if (emp != null) {
em.remove(emp);
}
}

public Employee raiseEmployeeSalary(int id, long raise) {
Employee emp = em.find(Employee.class, id);
if (emp != null) {
emp.setSalary(emp.getSalary() + raise);
}
return emp;
}

public Employee findEmployee(int id) {
return em.find(Employee.class, id);
}

public Collection<Employee> findAllEmployees() {
Query query = em.createQuery(“SELECT e FROM Employee e”);
return (Collection<Employee>) query.getResultList();
}
}

import java.util.Set;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Employee {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int id;
private String name;
private long salary;

// Collection of basic type – String type in this case
@ElementCollection
// Name the table as “expertise”
@CollectionTable(name = “expertise”)
private Set<String> javaskills;

// Collection of embeddable type
@ElementCollection
// Name the table as “expertise”
@CollectionTable(name = “vacationhomes”)
private Set<Address> vacationHomes;

public Employee() {
}

public Employee(int id) {
this.id = id;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

@Override;
public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the javaskills
*/
public Set<String> geJavaskills() {
return javaskills;
}

/**
* @param javaskills the javaskills to set
*/
public void seJavaskills(Set<String> javaskills) {
this.javaskills = javaskills;
}

/**
* @return the vacationHomes
*/
public Set<Address> getVacationHomes() {
return vacationHomes;
}

/**
* @param vacationHomes the vacationHomes to set
*/
public void setVacationHomes(Set<Address> vacationHomes) {
this.vacationHomes = vacationHomes;
}
}

import java.io.Serializable;
import javax.persistence.Embeddable;

@Embeddable
public class Address implements Serializable{
private String street;
private String city;
private String state;

public Address(){

}

public Address(String street, String city, String state) {
this.street = street;
this.city = city;
this.state = state;
}

/**
* @return the street
*/
public String getStreet() {
return street;
}

/**
* @param street the street to set
*/
public void setStreet(String street) {
this.street = street;
}

/**
* @return the city
*/
public String getCity() {
return city;
}

/**
* @param city the city to set
*/
public void setCity(String city) {
this.city = city;
}

/**
* @return the state
*/
public String getState() {
return state;
}

/**
* @param state the state to set
*/
public void setState(String state) {
this.state = state;
}
}

import examples.model.Address;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.EmployeeService;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.EntityTransaction;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

es.createEmployee(“Sang Shin”, 10000);
Set<String> javaskills = new HashSet<String>();
javaskills.add(“servlet”);
javaskills.add(“ejb”);
es.setJavaskills(1, javaskills);

Set<Address> vacationHomes = new HashSet<Address>();
vacationHomes.add(new Address(“1 dreamland st”, “newton”, “MA”));
vacationHomes.add(new Address(“22 marthas vineyard”, “cape cod”, “MA”));
es.setVacationHomes(1, vacationHomes);

es.createEmployee(“Bill Clinton”, 8000);
javaskills = new HashSet<String>();
javaskills.add(“jsf”);
javaskills.add(“ejb”);
es.setJavaskills(2, javaskills);

es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
es.createEmployee(“Charles Lannie”, 7500);
es.createEmployee(“Shelley Nichole”, 8500);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from EXPERTISE”);
JPAUtil.checkData(“select * from VACATIONHOMES”);

em.close();
emf.close();

}
}

import java.util.Set;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Employee {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int id;
private String name;
private long salary;

// Collection of basic type – Stting type in this case
@ElementCollection
// Name the table as “expertise”
@CollectionTable(name = “expertise”)
private Set<String> javaskills;

// Collection of embeddable type
@ElementCollection
@CollectionTable(name = “vacationhomes”)
private Set<Address> vacationHomes;

// Multi-levels of Embeddable
private ContactInfo contactInfo;

public Employee() {
}

public Employee(int id) {
this.id = id;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

@Override;
public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the javaskills
*/
public Set<String> geJavaskills() {
return javaskills;
}

/**
* @param javaskills the javaskills to set
*/
public void seJavaskills(Set<String> javaskills) {
this.javaskills = javaskills;
}

/**
* @return the vacationHomes
*/
public Set<Address> getVacationHomes() {
return vacationHomes;
}

/**
* @param vacationHomes the vacationHomes to set
*/
public void setVacationHomes(Set<Address> vacationHomes) {
this.vacationHomes = vacationHomes;
}

/**
* @return the contactInfo
*/
public ContactInfo getContactInfo() {
return contactInfo;
}

/**
* @param contactInfo the contactInfo to set
*/
public void setContactInfo(ContactInfo contactInfo) {
this.contactInfo = contactInfo;
}
}

import java.io.Serializable;
import javax.persistence.Embeddable;
import javax.persistence.Embedded;

@Embeddable
public class ContactInfo implements Serializable{
@Embedded private Address address;

public ContactInfo(){
}

public ContactInfo(Address address) {
this.address = address;
}

/**
* @return the address
*/
public Address getAddress() {
return address;
}

/**
* @param address the address to set
*/
public void setAddress(Address address) {
this.address = address;
}

}

import java.io.Serializable;
import javax.persistence.Embeddable;

@Embeddable
public class Address implements Serializable{
private String street;
private String city;
private String state;

public Address(){

}

public Address(String street, String city, String state) {
this.street = street;
this.city = city;
this.state = state;
}

/**
* @return the street
*/
public String getStreet() {
return street;
}

/**
* @param street the street to set
*/
public void setStreet(String street) {
this.street = street;
}

/**
* @return the city
*/
public String getCity() {
return city;
}

/**
* @param city the city to set
*/
public void setCity(String city) {
this.city = city;
}

/**
* @return the state
*/
public String getState() {
return state;
}

/**
* @param state the state to set
*/
public void setState(String state) {
this.state = state;
}
}

import examples.model.Address;
import examples.model.ContactInfo;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.EmployeeService;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.EntityTransaction;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

// First employee
es.createEmployee(“Sang Shin”, 10000);

Set<String> javaskills = new HashSet<String>();
javaskills.add(“servlet”);
javaskills.add(“ejb”);
es.setJavaskills(1, javaskills);

Set<Address> vacationHomes = new HashSet<Address>();
vacationHomes.add(new Address(“1 dreamland st”, “newton”, “MA”));
vacationHomes.add(new Address(“22 marthas vineyard”, “cape cod”, “MA”));
es.setVacationHomes(1, vacationHomes);

ContactInfo contactInfo = new ContactInfo(new Address(“1 dreamland road”, “Newton”, “MA”));
es.setContactInfo(1, contactInfo);

// 2nd employee
es.createEmployee(“Bill Clinton”, 8000);
javaskills = new HashSet<String>();
javaskills.add(“jsf”);
javaskills.add(“ejb”);
es.setJavaskills(2, javaskills);

es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
es.createEmployee(“Charles Lannie”, 7500);
es.createEmployee(“Shelley Nichole”, 8500);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from EXPERTISE”);
JPAUtil.checkData(“select * from VACATIONHOMES”);

em.close();
emf.close();

}
}

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Employee implements Serializable {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int id;
private String name;
private long salary;

// Multi-levels of Embeddable
private ContactInfo contactInfo;

public Employee() {
}

public Employee(int id) {
this.id = id;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

@Override;
public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the contactInfo
*/
public ContactInfo getContactInfo() {
return contactInfo;
}

/**
* @param contactInfo the contactInfo to set
*/
public void setContactInfo(ContactInfo contactInfo) {
this.contactInfo = contactInfo;
}
}

import java.io.Serializable;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Embeddable;
import javax.persistence.Embedded;
import javax.persistence.OneToMany;

@Embeddable
public class ContactInfo implements Serializable{
@Embedded private Address address;

// One-to-many bidirectional relationship between
// ContactInfo and Phone.
// The “employee” is a field in the Phone.
@OneToMany(cascade=CascadeType.ALL, mappedBy=”employee”)
private Set<Phone> phones;

public ContactInfo(){
}

public ContactInfo(Address address) {
this.address = address;
}

/**
* @return the address
*/
public Address getAddress() {
return address;
}

/**
* @param address the address to set
*/
public void setAddress(Address address) {
this.address = address;
}

/**
* @return the phones
*/
public Set<Phone> getPhones() {
return phones;
}

/**
* @param phones the phones to set
*/
public void setPhones(Set<Phone> phones) {
this.phones = phones;
}

}

@Entity
@Table(name = “PHONE_TABLE”)
public class Phone implements Serializable {

@Id
@Column(name = “PHONE_ID”)
@GeneratedValue
private int id;
private String phoneNumber;

// Bi-directional one-to-many relationship
@ManyToOne(optional = true)
private Employee employee;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public Phone() {
}

public Phone(String phoneNumber, Employee emp) {
this.phoneNumber = phoneNumber;
this.employee = emp;
}

public Phone(int id, String phoneNumber) {
this.id = id;
this.phoneNumber = phoneNumber;
}

public String getPhoneNumber() {
return phoneNumber;
}

/**
* @param phoneNumber the phoneNumber to set
*/
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}

/**
* @return the employee
*/
public Employee getEmployee() {
return employee;
}

/**
* @param employee the employee to set
*/
public void setEmployee(Employee employee) {
this.employee = employee;
}
}

import examples.model.Address;
import examples.model.ContactInfo;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import examples.model.Phone;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

// First employee
Employee emp = es.createEmployee(“Sang Shin”, 10000);
Set<Phone> phones = new HashSet<Phone>();
phones.add(new Phone(“111-3333-3333”, emp));
phones.add(new Phone(“111-1233-6666”, emp));
ContactInfo contactInfo = new ContactInfo(new Address(“1 dreamland road”, “Newton”, “MA”));
contactInfo.setPhones(phones);
es.setContactInfo(emp, contactInfo);
es.updateEmployee(emp);

// Second employee
emp =  es.createEmployee(“Bill Clinton”, 8000);
phones = new HashSet<Phone>();
phones.add(new Phone(“222-3333-3333”, emp));
phones.add(new Phone(“222-1233-6666”, emp));
contactInfo = new ContactInfo(new Address(“7 Green St”, “Ohmygodgown”, “PA”));
contactInfo.setPhones(phones);
es.setContactInfo(emp, contactInfo);
es.updateEmployee(emp);

// Perform query – Retrieve all employees whose street is
// “1 dteamland road”.
String jpql = “SELECT e FROM Employee e WHERE e.contactInfo.address.street = ?1”;
Query query = em.createQuery(jpql);
query.setParameter(1, “1 dreamland road”);
List<Employee> emps = query.getResultList();
displayQueryResult(jpql, emps);

// Perform query – Retrieve all employees who have a specific phone number
// in their contactinfo
jpql = “SELECT e FROM Employee e ”
+ “JOIN e.contactInfo.phones p WHERE p.phoneNumber = ?1”;
query = em.createQuery(jpql);
query.setParameter(1, “222-3333-3333”);
emps = query.getResultList();
displayQueryResult(jpql, emps);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from PHONE_TABLE”);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

import java.util.List;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OrderColumn;

@Entity
public class Employee {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int id;
private String name;
private long salary;

// Collection of basic type – Stting type in this case
@ElementCollection
// Specifies a column that is used to maintain the persistent order of a list.
@OrderColumn(name=”INDEX”)
// Name the table as “phones”
@CollectionTable(name = “phones”)
private List<String> phones;

public Employee() {
}

public Employee(int id) {
this.id = id;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

@Overrride
public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the phones
*/
public List<String> getPhones() {
return phones;
}

/**
* @param phones the phones to set
*/
public void sePhones(List<String> phones) {
this.phones = phones;
}
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityTransaction;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

Employee emp = es.createEmployee(“Sang Shin”, 10000);
List<String> phones = new ArrayList<String>();
phones.add(“111-111-1234”);
phones.add(“111-111-2345”);
phones.add(“111-111-2341”);
phones.add(“111-111-3455”);
es.setPhones(emp, phones);

emp = es.createEmployee(“Bill Clinton”, 8000);
phones = new ArrayList<String>();
phones.add(“222-222-4252”);
phones.add(“222-222-2452”);
es.setPhones(emp, phones);

es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
es.createEmployee(“Charles Lannie”, 7500);
es.createEmployee(“Shelley Nichole”, 8500);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from PHONES”);

em.close();
emf.close();

}
}

import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.OrderColumn;

@Entity
public class Employee {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int id;

private String name;
private long salary;

// Unidirectional One-to-Many association using a foreign key mapping
@OneToMany(cascade=CascadeType.ALL, orphanRemoval=true)
// The join column is in table for Phone (for Unidirectional relationship)
@JoinColumn(name=”EMPLOYEE_ID”)
// Specifies a column that is used to maintain the persistent order of a list.
@OrderColumn(name = “INDEX”)
private List<Phone> phones;

public Employee() {
}

public Employee(int id) {
this.id = id;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the phones
*/
public List<Phone> getPhones() {
return phones;
}

/**
* @param phones the phones to set
*/
public void sePhones(List<Phone> phones) {
this.phones = phones;
}
}

import java.io.Serializable;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.OrderColumn;

@Entity
public class Employee implements Serializable {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int eid;

private String name;
private long salary;

// Bidirectional one to many relationship through “mappedBy”.
// The value of “mappedBy” is a field of Phone entity class.
@OneToMany(cascade=CascadeType.ALL, mappedBy=”employee”)
// Specifies a column that is used to maintain the persistent order of a list.
@OrderColumn(name = “INDEX”)
private List<Phone> phones;

public Employee() {
}

public Employee(int id) {
this.eid = id;
}

public int getId() {
return eid;
}

public void setId(int id) {
this.eid = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

@Override
public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the phones
*/
public List<Phone> getPhones() {
return phones;
}

/**
* @param phones the phones to set
*/
public void sePhones(List<Phone> phones) {
this.phones = phones;
}
}

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = “PHONE_TABLE”)
public class Phone implements Serializable {

@Id
@Column(name = “PHONE_ID”)
@GeneratedValue
private int id;
private String phoneNumber;

// Bi-directional one-to-many relationship
@ManyToOne(optional = false)
private Employee employee;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public Phone() {
}

public Phone(String phoneNumber, Employee emp) {
this.phoneNumber = phoneNumber;
this.employee = emp;
}

public Phone(int id, String phoneNumber) {
this.id = id;
this.phoneNumber = phoneNumber;
}

public String getPhoneNumber() {
return phoneNumber;
}

/**
* @param phoneNumber the phoneNumber to set
*/
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}

/**
* @return the employee
*/
public Employee getEmployee() {
return employee;
}

/**
* @param employee the employee to set
*/
public void setEmployee(Employee employee) {
this.employee = employee;
}
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import examples.model.Phone;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityTransaction;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

// Perform JPA operations
EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

// Create some employees
EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

Employee emp = es.createEmployee(“Sang Shin”, 10000);
List<Phone> phones = new ArrayList<Phone>();
phones.add(new Phone(“111-111-1234”, emp));
phones.add(new Phone(“111-111-2345”, emp));
phones.add(new Phone(“111-111-2341”, emp));
phones.add(new Phone(“111-111-3455”, emp));
es.setPhones(emp, phones);
es.updateEmployee(emp);

emp = es.createEmployee(“Bill Clinton”, 8000);
phones = new ArrayList<Phone>();
phones.add(new Phone(“222-222-4252”, emp));
phones.add(new Phone(“222-222-2452”, emp));
es.setPhones(emp, phones);
es.updateEmployee(emp);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from PHONE_TABLE”);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

import java.io.Serializable;
import java.util.Map;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MapKeyColumn;
import javax.persistence.OneToMany;

@Entity
public class Employee implements Serializable {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int eid;

private String name;
private long salary;

// Bidirectional one to many relationship through “mappedBy”.
// The value of “mappedBy” is a field of Phone entity class.
@OneToMany(cascade=CascadeType.ALL, mappedBy=”employee”)
// The @MapKeyColumn annotation is used to define a map
// relationship where the key is a Basic value
@MapKeyColumn(name=”PHONE_TYPE”)
private Map<String, Phone> phones;

public Employee() {
}

public Employee(int id) {
this.eid = id;
}

public int getId() {
return eid;
}

public void setId(int id) {
this.eid = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

@Override
public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the phones
*/
public Map<String, Phone> getPhones() {
return phones;
}

/**
* @param phones the phones to set
*/
public void setPhones(Map<String, Phone> phones) {
this.phones = phones;
}

}

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = “PHONE_TABLE”)
public class Phone implements Serializable {

@Id
@Column(name = “PHONE_ID”)
@GeneratedValue
private int id;
private String phoneNumber;

// Bi-directional one-to-many relationship
@ManyToOne(optional = false)
private Employee employee;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public Phone() {
}

public Phone(String phoneNumber, Employee emp) {
this.phoneNumber = phoneNumber;
this.employee = emp;
}

public Phone(int id, String phoneNumber) {
this.id = id;
this.phoneNumber = phoneNumber;
}

public String getPhoneNumber() {
return phoneNumber;
}

/**
* @param phoneNumber the phoneNumber to set
*/
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}

/**
* @return the employee
*/
public Employee getEmployee() {
return employee;
}

/**
* @param employee the employee to set
*/
public void setEmployee(Employee employee) {
this.employee = employee;
}
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import examples.model.Phone;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityTransaction;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

// Perform JPA operations
EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

// Create some employees
EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

Employee emp = es.createEmployee(“Sang Shin”, 10000);
Map<String, Phone> phones = new HashMap<String, Phone>();
phones.put(“cell”, new Phone(“111-111-1234”, emp));
phones.put(“home”, new Phone(“111-111-2345”, emp));
phones.put(“fax”, new Phone(“111-111-2341”, emp));
phones.put(“cell2”, new Phone(“111-111-3455”, emp));
es.setPhones(emp, phones);
es.updateEmployee(emp);

emp = es.createEmployee(“Bill Clinton”, 8000);
phones = new HashMap<String, Phone>();
phones.put(“home”, new Phone(“222-222-4252”, emp));
phones.put(“cell”, new Phone(“222-222-2452”, emp));
es.setPhones(emp, phones);
es.updateEmployee(emp);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from PHONE_TABLE”);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

import java.io.Serializable;
import java.util.Map;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MapKeyClass;
import javax.persistence.OneToMany;

@Entity
public class Employee implements Serializable {

@Id
@GeneratedValue
@Column(name = “EMPLOYEE_ID”)
private int eid;

private String name;
private long salary;

// Bidirectional one to many relationship through “mappedBy”.
// The value of “mappedBy” is a field of Phone entity class.
@OneToMany(cascade=CascadeType.ALL)
// Specifies the type of the map key for associations of type
// java.util.Map. The map key can be a basic type, an embeddable
// class, or an entity. If the map is specified using Java generics,
// the MapKeyClass annotation and associated type need not be
// specified; otherwise they must be specified.
// @MapKeyClass(PhoneType.class)  // Not needed in this case
private Map<PhoneType, Phone> phones;

public Employee() {
}

public Employee(int id) {
this.eid = id;
}

public int getId() {
return eid;
}

public void setId(int id) {
this.eid = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public long getSalary() {
return salary;
}

public void setSalary(long salary) {
this.salary = salary;
}

@Override
public String toString() {
return “Employee id: ” + getId() + ” name: ” + getName() + ” salary: ” + getSalary();
}

/**
* @return the phones
*/
public Map<PhoneType, Phone> getPhones() {
return phones;
}

/**
* @param phones the phones to set
*/
public void setPhones(Map<PhoneType, Phone> phones) {
this.phones = phones;
}

}

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = “PHONE_TABLE”)
public class Phone implements Serializable {

@Id
@Column(name = “PHONE_ID”)
@GeneratedValue
private int id;
private String phoneNumber;

// Bi-directional one-to-many relationship
@ManyToOne(optional = false)
private Employee employee;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public Phone() {
}

public Phone(String phoneNumber) {
this.phoneNumber = phoneNumber;
}

public Phone(int id, String phoneNumber) {
this.id = id;
this.phoneNumber = phoneNumber;
}

public String getPhoneNumber() {
return phoneNumber;
}

/**
* @param phoneNumber the phoneNumber to set
*/
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}

/**
* @return the employee
*/
public Employee getEmployee() {
return employee;
}

/**
* @param employee the employee to set
*/
public void setEmployee(Employee employee) {
this.employee = employee;
}
}

import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Embeddable;

@Embeddable
public class PhoneType implements Serializable {

@Basic
private String type;

public PhoneType() {
}

public PhoneType(String type) {
this.type = type;
}

/**
* @return the type
*/
public String getType() {
return type;
}

/**
* @param type the type to set
*/
public void setType(String type) {
this.type = type;
}

}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import examples.model.Phone;
import examples.model.PhoneType;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityTransaction;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

// Perform JPA operations
EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

// Create some employees
EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

Employee emp = es.createEmployee(“Sang Shin”, 10000);
Map<PhoneType, Phone> phones = new HashMap<PhoneType, Phone>();
phones.put(new PhoneType(“cell”), new Phone(“111-111-1234”, emp));
phones.put(new PhoneType(“home”), new Phone(“111-111-2345”, emp));
phones.put(new PhoneType(“fax”), new Phone(“111-111-2341”, emp));
phones.put(new PhoneType(“cell2”), new Phone(“111-111-3455”, emp));
es.setPhones(emp, phones);
es.updateEmployee(emp);

emp = es.createEmployee(“Bill Clinton”, 8000);
phones = new HashMap<PhoneType, Phone>();
phones.put(new PhoneType(“home”), new Phone(“222-222-4252”, emp));
phones.put(new PhoneType(“cell”), new Phone(“222-222-2452”, emp));
es.setPhones(emp, phones);
es.updateEmployee(emp);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from PHONE_TABLE”);
JPAUtil.checkData(“select * from EMPLOYEE_PHONE_TABLE”);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

—— Query result of “SELECT DISTINCT e FROM Employee e INNER JOIN e.phones p WHERE e.name = ‘Sang Shin’ AND INDEX(p) < 3 ”
Employee 1, Sang Shin, 10000

—— Query result of “SELECT e FROM Employee e INNER JOIN e.phones p WHERE e.name = ‘Sang Shin’ AND INDEX(p) < 1 ”
Employee 1, Sang Shin, 10000

—— Query result of “SELECT DISTINCT e FROM Employee e INNER JOIN e.phones p WHERE INDEX(p) BETWEEN 0 AND 4 ”
Employee 1, Sang Shin, 10000
Employee 2, Bill Clinton, 8000

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import examples.model.Phone;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

// Perform JPA operations
EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

// Create some employees
EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

Employee emp = es.createEmployee(“Sang Shin”, 10000);
List<Phone> phones = new ArrayList<Phone>();
phones.add(new Phone(“111-111-1234”));
phones.add(new Phone(“111-111-2345”));
phones.add(new Phone(“111-111-2341”));
phones.add(new Phone(“111-111-3455”));
es.setPhones(emp, phones);

emp = es.createEmployee(“Bill Clinton”, 8000);
phones = new ArrayList<Phone>();
phones.add(new Phone(“222-222-4252”));
phones.add(new Phone(“222-222-2452”));
es.setPhones(emp, phones);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);
JPAUtil.checkData(“select * from PHONE_TABLE”);

// Usage of INDEX example
String jpql = “SELECT e ”
+ “FROM Employee e INNER JOIN e.phones p ”
+ “WHERE e.name = ‘Sang Shin’ ”
+ “AND INDEX(p) < 3 “;

Query query = em.createQuery(jpql);
List<Employee> emps = query.getResultList();
displayQueryResult(jpql, emps);

// Usage of INDEX example
jpql = “SELECT DISTINCT e ”
+ “FROM Employee e INNER JOIN e.phones p ”
+ “WHERE e.name = ‘Sang Shin’ ”
+ “AND INDEX(p) < 3 “;

query = em.createQuery(jpql);
emps = query.getResultList();
displayQueryResult(jpql, emps);

// Usage of INDEX example
jpql = “SELECT e ”
+ “FROM Employee e INNER JOIN e.phones p ”
+ “WHERE e.name = ‘Sang Shin’ ”
+ “AND INDEX(p) < 1 “;

query = em.createQuery(jpql);
emps = query.getResultList();
displayQueryResult(jpql, emps);

// Usage of INDEX example
jpql = “SELECT DISTINCT e ”
+ “FROM Employee e INNER JOIN e.phones p ”
+ “WHERE INDEX(p) BETWEEN 0 AND 4 “;

query = em.createQuery(jpql);
emps = query.getResultList();
displayQueryResult(jpql, emps);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.EmployeeService;

import javax.persistence.Query;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

em.getTransaction().begin();
es.createEmployee(“Sang Shin”, 10000);
es.createEmployee(“Bill Clinton”, 8000);
es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
em.getTransaction().commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);

// Use CASE
String jpql = “UPDATE Employee e SET e.salary = ” +
“CASE WHEN e.salary > 9000 THEN e.salary * 1.10 ” +
”     WHEN e.salary > 7500 THEN e.salary * 1.08 ” +
”     ELSE e.salary * 0.95 ” +
“END” ;
Query q = em.createQuery(jpql);

em.getTransaction().begin();
int updated = q.executeUpdate();
em.getTransaction().commit();
displayQueryResult(jpql, updated);

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, int deleted) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
System.out.println(“Number of updated records ” + deleted);
}
}

******* Query result using Criteria API
Employee 3, Angela Caicedo, 6000
Employee 5, Charles Song, 4500
Employee 1, Sang Shin, 10000
Employee 4, Annie Song, 5000
Employee 2, Bill Clinton, 8000

—— Query result of “SELECT e FROM Employee e where e.name = ‘Sang Shin'”
Employee 1, Sang Shin, 10000

******* Query result using Criteria API
Employee 1, Sang Shin, 10000

—— Query result of “SELECT e FROM Employee e where e.name = ‘Sang Shin’ OR e.salary > 7000”
Employee 1, Sang Shin, 10000
Employee 2, Bill Clinton, 8000

******* Query result using Criteria API
Employee 1, Sang Shin, 10000
Employee 2, Bill Clinton, 8000

—— Query result of “SELECT e FROM Employee e where e.name LIKE ‘A%'”
Employee 3, Angela Caicedo, 6000
Employee 4, Annie Song, 5000

******* Query result using Criteria API
Employee 3, Angela Caicedo, 6000
Employee 4, Annie Song, 5000

—— Query result of “SELECT e FROM Employee e where e.name IN (‘Sang Shin’, ‘Bill Clinton’, ‘Some name’)”
Employee 1, Sang Shin, 10000
Employee 2, Bill Clinton, 8000

******* Query result using Criteria API
Employee 1, Sang Shin, 10000

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import java.util.List;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

em.getTransaction().begin();
es.createEmployee(“Sang Shin”, 10000);
es.createEmployee(“Bill Clinton”, 8000);
es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
es.createEmployee(“Charles Song”, 4500);
em.getTransaction().commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);

// Get all employees whose name is ‘Sang Shin’
String jpql = “SELECT e FROM Employee e”;
List<Employee> emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
CriteriaBuilder cbuilder = em.getEntityManagerFactory().getCriteriaBuilder();
CriteriaQuery<Employee> criteria = cbuilder.createQuery(Employee.class);
Root<Employee> employee = criteria.from(Employee.class);

// —- Build criteria
criteria.select(employee);

// —- Create a query object from Criteria and perform query operation
//TypedQuery<Employee> q = em.createQuery(criteria);
//emps = q.getResultList();
emps = em.createQuery(criteria).getResultList();

// —- Display the result
displayQueryResult2(emps);

// Get all employees whose name is ‘Sang Shin’
jpql = “SELECT e FROM Employee e where e.name = ‘Sang Shin'”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API

// —- Build criteria
criteria.select(employee);
criteria.where(cbuilder.equal(employee.get(“name”), “Sang Shin”));

// —- Create a query object from Criteria and perform query operation
emps = em.createQuery(criteria).getResultList();

// —- Display the result
displayQueryResult2(emps);

// Get all employees whose name is ‘Sang Shin’ or whose salary is greater than 7000
jpql = “SELECT e FROM Employee e where e.name = ‘Sang Shin’ OR e.salary > 7000”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(cbuilder.or(cbuilder.equal(employee.get(“name”), “Sang Shin”), cbuilder.greaterThan(employee.get(“salary”).as(Integer.class), 7000)));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

// Get all emplyees whose name starts with A
jpql = “SELECT e FROM Employee e where e.name LIKE ‘A%'”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(cbuilder.like(employee.get(“name”).as(String.class),  “A%”));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

// Get all employees whose name is either ‘Sang Shin’ or ‘Bill Clinton” or ‘Some name’
jpql = “SELECT e FROM Employee e where e.name IN (‘Sang Shin’, ‘Bill Clinton’, ‘Some name’)”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(employee.get(“name”).in(“Sang Shin”, “Bill Clinton”, “Some name”));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}

// Display the query result
public static void displayQueryResult2(List<Employee> emps) {
System.out.println(“\n******* Query result using Criteria API”);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import java.util.List;
import javax.persistence.EntityTransaction;

import javax.persistence.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

EntityTransaction tx = em.getTransaction();
tx.begin();

es.createEmployee(“Sang Shin”, 10000);
es.createEmployee(“Bill Clinton”, 8000);
es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
es.createEmployee(“Charles Lannie”, 7500);
es.createEmployee(“Shelley Nichole”, 8500);

tx.commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);

// Perform JPA query with ORDER BY
String jpql = “SELECT e FROM Employee e ”
+ “WHERE e.salary > 4000 ”
+ “ORDER BY e.name ASC, e.salary DESC”;
Query q = em.createQuery(jpql);
List<Employee> emps = q.getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
CriteriaBuilder cbuilder = em.getEntityManagerFactory().getCriteriaBuilder();
CriteriaQuery<Employee> criteria = cbuilder.createQuery(Employee.class);
Root<Employee> employee = criteria.from(Employee.class);

// Create criteria
criteria.select(employee);
criteria.where(cbuilder.or(cbuilder.equal(employee.get(“name”), “Sang Shin”), cbuilder.greaterThan(employee.get(“salary”).as(Integer.class), 4000)));
criteria.orderBy(cbuilder.asc(employee.get(“name”)), cbuilder.desc(employee.get(“salary”)));

// Create query using Criteria and then perform query operation
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}

// Display the query result
public static void displayQueryResult2(List<Employee> emps) {
System.out.println(“\n******* Query result using Criteria API”);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

import customer.model.Customer;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import java.util.List;

import javax.persistence.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“CustomerServicePU”);
EntityManager em = emf.createEntityManager();

// Display the test table
JPAUtil.checkData(“select CUSTOMER_ID, DISCOUNT_CODE, NAME, EMAIL from CUSTOMER”);
JPAUtil.checkData(“select * from DISCOUNT_CODE”);

// Display all customers whose discount rate is bigger than 10%
String jpql = “SELECT c FROM Customer c WHERE c.discountCode.rate > 10”;
Query query = em.createQuery(jpql);
List<Customer> customers = query.getResultList();
displayQueryResult(jpql, customers);

///////// Perform the same query using Criteria API
CriteriaBuilder cbuilder = em.getEntityManagerFactory().getCriteriaBuilder();
CriteriaQuery<Customer> criteria = cbuilder.createQuery(Customer.class);
Root<Customer> Customer = criteria.from(Customer.class);

// Create criteria
criteria.select(Customer);
criteria.where(cbuilder.greaterThan(Customer.get(“discountCode”).get(“rate”).as(Integer.class), 10));

// Create query using Criteria and then perform query operation
customers = em.createQuery(criteria).getResultList();
displayQueryResult2(customers);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Customer> customers) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Customer e : customers) {
System.out.println(“Customer id = ” + e.getCustomerId() + “, name = ” + e.getName() + “, discount rate = ” + e.getDiscountCode().getRate());
}
}

// Display the query result
public static void displayQueryResult2(List<Customer> customers) {
System.out.println(“\n******* Query result using Criteria API”);
for (Customer e : customers) {
System.out.println(“Customer id = ” + e.getCustomerId() + “, name = ” + e.getName() + “, discount rate = ” + e.getDiscountCode().getRate());
}
}
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import java.util.List;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.EntityType;
import javax.persistence.metamodel.Metamodel;

import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

em.getTransaction().begin();
es.createEmployee(“Sang Shin”, 10000);
es.createEmployee(“Bill Clinton”, 8000);
es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
es.createEmployee(“Charles Song”, 4500);
em.getTransaction().commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);

// Get all employees whose name is ‘Sang Shin’
String jpql = “SELECT e FROM Employee e”;
List<Employee> emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
CriteriaBuilder cbuilder = em.getEntityManagerFactory().getCriteriaBuilder();
CriteriaQuery<Employee> criteria = cbuilder.createQuery(Employee.class);

// Use Metamodel – Obtaining a Metamodel Class Dynamically Using the Metamodel.getMetamodel Method
Metamodel m = em.getMetamodel();
EntityType<Employee> Employee_ = m.entity(Employee.class);
Root<Employee> employee = criteria.from(Employee_);
//Root<Employee> employee = criteria.from(Employee.class);

// —- Build criteria
criteria.select(employee);

// —- Create a query object from Criteria and perform query operration
//TypedQuery<Employee> q = em.createQuery(criteria);
//emps = q.getResultList();
emps = em.createQuery(criteria).getResultList();

// —- Display the result
displayQueryResult2(emps);

// Get all employees whose name is ‘Sang Shin’
jpql = “SELECT e FROM Employee e where e.name = ‘Sang Shin'”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API

// —- Build criteria
criteria.select(employee);
criteria.where(cbuilder.equal(employee.get(“name”), “Sang Shin”));

// —- Create a query object from Criteria and perform query operration
emps = em.createQuery(criteria).getResultList();

// —- Display the result
displayQueryResult2(emps);

// Get all employees whose name is ‘Sang Shin’ or whose salary is greater than 7000
jpql = “SELECT e FROM Employee e where e.name = ‘Sang Shin’ OR e.salary > 7000”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(cbuilder.or(cbuilder.equal(employee.get(“name”), “Sang Shin”), cbuilder.greaterThan(employee.get(“salary”).as(Integer.class), 7000)));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

// Get all emplyees whose name starts with A
jpql = “SELECT e FROM Employee e where e.name LIKE ‘A%'”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(cbuilder.like(employee.get(“name”).as(String.class), “A%”));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

// Get all employees whose name is either ‘Sang Shin’ or ‘Bill Clinton” or ‘Some name’
jpql = “SELECT e FROM Employee e where e.name IN (‘Sang Shin’, ‘Bill Clinton’, ‘Some name’)”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(employee.get(“name”).in(“Sang Shin”, “Bill Clinton”, “Some name”));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}

// Display the query result
public static void displayQueryResult2(List<Employee> emps) {
System.out.println(“\n******* Query result using Criteria API”);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import examples.model.Employee;
import examples.model.EmployeeService;
import java.util.List;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.EntityType;
import javax.persistence.metamodel.Metamodel;

import util.JPAUtil;

public class Main {

public static void main(String[] args) throws Exception {

EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“EmployeeService”);
EntityManager em = emf.createEntityManager();

EmployeeService es = new EmployeeService(em);

em.getTransaction().begin();
es.createEmployee(“Sang Shin”, 10000);
es.createEmployee(“Bill Clinton”, 8000);
es.createEmployee(“Angela Caicedo”, 6000);
es.createEmployee(“Annie Song”, 5000);
es.createEmployee(“Charles Song”, 4500);
em.getTransaction().commit();

// Display the table
JPAUtil.checkData(“select * from EMPLOYEE”);

// Get all employees whose name is ‘Sang Shin’
String jpql = “SELECT e FROM Employee e”;
List<Employee> emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
CriteriaBuilder cbuilder = em.getEntityManagerFactory().getCriteriaBuilder();
CriteriaQuery<Employee> criteria = cbuilder.createQuery(Employee.class);

// Use Metamodel – Obtaining a Metamodel Class Dynamically Using the Root<T>.getModel Method
Root<Employee> employee = criteria.from(Employee.class);
EntityType<Employee> Employee_ = employee.getModel();
employee = criteria.from(Employee_);

// —- Build criteria
criteria.select(employee);

// —- Create a query object from Criteria and perform query operration
//TypedQuery<Employee> q = em.createQuery(criteria);
//emps = q.getResultList();
emps = em.createQuery(criteria).getResultList();

// —- Display the result
displayQueryResult2(emps);

// Get all employees whose name is ‘Sang Shin’
jpql = “SELECT e FROM Employee e where e.name = ‘Sang Shin'”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API

// —- Build criteria
criteria.select(employee);
criteria.where(cbuilder.equal(employee.get(“name”), “Sang Shin”));

// —- Create a query object from Criteria and perform query operration
emps = em.createQuery(criteria).getResultList();

// —- Display the result
displayQueryResult2(emps);

// Get all employees whose name is ‘Sang Shin’ or whose salary is greater than 7000
jpql = “SELECT e FROM Employee e where e.name = ‘Sang Shin’ OR e.salary > 7000”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(cbuilder.or(cbuilder.equal(employee.get(“name”), “Sang Shin”), cbuilder.greaterThan(employee.get(“salary”).as(Integer.class), 7000)));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

// Get all emplyees whose name starts with A
jpql = “SELECT e FROM Employee e where e.name LIKE ‘A%'”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(cbuilder.like(employee.get(“name”).as(String.class), “A%”));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

// Get all employees whose name is either ‘Sang Shin’ or ‘Bill Clinton” or ‘Some name’
jpql = “SELECT e FROM Employee e where e.name IN (‘Sang Shin’, ‘Bill Clinton’, ‘Some name’)”;
emps = em.createQuery(jpql).getResultList();
displayQueryResult(jpql, emps);

///////// Perform the same query using Criteria API
criteria.select(employee);
criteria.where(employee.get(“name”).in(“Sang Shin”, “Bill Clinton”, “Some name”));
emps = em.createQuery(criteria).getResultList();
displayQueryResult2(emps);

em.close();
emf.close();

}

// Display the query result
public static void displayQueryResult(String jpql, List<Employee> emps) {
System.out.println(“\n—— Query result of \”” + jpql + “\””);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}

// Display the query result
public static void displayQueryResult2(List<Employee> emps) {
System.out.println(“\n******* Query result using Criteria API”);
for (Employee e : emps) {
System.out.println(“Employee ” + e.getId() + “, ” + e.getName() + “, ” + e.getSalary());
}
}
}

Starting parallel updates with 9 users for operation: updateWOL
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=1
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=3
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=5
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=8
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=6
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=4
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=2
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=9
Calling URL:http://localhost:8080/locking/test/?tc=updateWOL&uid=7
Result for operation updateWOL for userId 6 is Success
Result for operation updateWOL for userId 8 is Success
Result for operation updateWOL for userId 3 is Success
Result for operation updateWOL for userId 5 is Failure
Result for operation updateWOL for userId 9 is Success
Result for operation updateWOL for userId 1 is Failure
Result for operation updateWOL for userId 4 is Success
Result for operation updateWOL for userId 7 is Success
Result for operation updateWOL for userId 2 is Failure
Parallel updates executed with 9 users for operation: updateWOL Time taken:7630 miliseconds

Starting parallel updates with 9 users for operation: updateWPL
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=1
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=3
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=5
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=7
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=9
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=8
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=2
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=6
Calling URL:http://localhost:8080/locking/test/?tc=updateWPL&uid=4
Result for operation updateWPL for userId 7 is Success
Result for operation updateWPL for userId 9 is Success
Result for operation updateWPL for userId 4 is Success
Result for operation updateWPL for userId 6 is Success
Result for operation updateWPL for userId 5 is Success
Result for operation updateWPL for userId 3 is Success
Result for operation updateWPL for userId 1 is Success
Result for operation updateWPL for userId 8 is Success
Result for operation updateWPL for userId 2 is Success
Parallel updates executed with 9 users for operation: updateWPL Time taken:11625 miliseconds
LockingJavaClient: Test is ended

package enterprise.locking.entity;

import javax.persistence.*;
import java.util.Set;

@Entity
@Table(name = “T_PART”)
public class Part implements java.io.Serializable {

// Instance variables
private int id;
private String name;
private int amount;
private int verNum;
private Set<User> users;

public Part() {
}

public Part(int id, String name) {
this.id = id;
this.name = name;
}

public Part(int id, String name, int amount) {
this.id = id;
this.name = name;
this.amount = amount;
}

// ==================================================
// getters and setters for the state fields

@Id
@Column(name = “PID”)
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

@Column(length = 20, name = “PNAME”)
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Column(name = “AMOUNT”)
public int getAmount() {
return amount;
}

public void setAmount(int amount) {
this.amount = amount;
}

@Version
@Column(name = “VER”)
public int getVerNum() {
return verNum;
}

public void setVerNum(int verNum) {
this.verNum = verNum;
}

// ===========================================================
// getters and setters for the association fields
@OneToMany(cascade = CascadeType.ALL, mappedBy = “part”)
public Set<User> getUsers() {
return users;
}

public void setUsers(Set<User> users) {
this.users = users;
}

public String toString() {
return “Product id=” + getId() + “, amount=” + getAmount();
}

}

package enterprise.locking.entity;

import javax.persistence.*;

@Entity
@Table(name = “T_USER”)
public class User implements java.io.Serializable {
public enum UserType {
CONSUMER, SUPPLIER
}

private int id;
private String firstName;
private String lastName;
private UserType userType;
private int count;
private Part part;

public User() {
}

public User(int id, String firstName, String lastName) {
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
}

public User(int id, String firstName, String lastName, UserType userType) {
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.userType = userType;
}

//=======================================================
// getters and setters for the state fields
@Id
@Column(name = “UID”)
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

@Column(length = 20, name = “FNAME”)
public String getFirstName() {
return firstName;
}

public void setFirstName(String firstName) {
this.firstName = firstName;
}

@Column(length = 20, name = “LNAME”)
public String getLastName() {
return lastName;
}

public void setLastName(String lastName) {
this.lastName = lastName;
}

@Column(name = “UTYPE”)
public UserType getUserType() {
return userType;
}

public void setUserType(UserType userType) {
this.userType = userType;
}

@Column(name = “COUNT”)
public int getCount() {
return count;
}

public void setCount(int count) {
this.count = count;
}

// ===========================================================
// getters and setters for the association fields
@ManyToOne
@JoinColumn(name = “PID”)
public Part getPart() {
return part;
}

public void setPart(Part part) {
this.part = part;
}

public String toString() {
return “User id=” + getId()
+ “, lastName=” + getLastName()
+ “, userType=” + getUserType();
}

}

import enterprise.locking.entity.Part;
import enterprise.locking.entity.User;

import javax.ejb.Stateless;
import javax.persistence.*;
import java.util.Random;

@Stateless
public class StatelessSessionBean {

@PersistenceContext
private EntityManager em;

private String name = “foo”;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

/**
* Initializes data for given number of consumers, suppliers and parts
*/
public void initData(int numberOfConsumers, int numberOfSuppliers, int numberOfParts) {
// user info
int uid = 0;
String fName = null;
String lName = null;
User u = null;
int pid = 0;
String pName = null;
Part p = null;
Part partRef[] = new Part[numberOfParts];

for (int i = 0; i < numberOfParts; i++) {
pid++;
pName = “p” + pid;
p = new Part(pid, pName);
p.setAmount(500);
partRef[i] = p;
em.persist(p);
}

int partIndex = 1;
Random randomGenerator = new Random();
for (int i = 0; i < numberOfConsumers; i++) {
uid++;
fName = “f” + uid;
lName = “l” + uid;
u = new User(uid, fName, lName);
u.setUserType(User.UserType.CONSUMER);
u.setCount(2);
// randam int from 0, …, NT-1
partIndex = randomGenerator.nextInt(numberOfParts);
u.setPart(partRef[partIndex]);
em.persist(u);
}

for (int i = 0; i < numberOfSuppliers; i++) {
uid++;
fName = “f” + uid;
lName = “l” + uid;
u = new User(uid, fName, lName);
u.setUserType(User.UserType.SUPPLIER);
u.setCount(10);
partIndex = randomGenerator.nextInt(numberOfParts);
u.setPart(partRef[partIndex]);
em.persist(u);
}
}

/**
* A find followed by some think time, followed by update.
*/
public boolean updateWithOptimisticLock(int uID, int s) {
boolean updateSuccessfull = true;
User u = em.find(User.class, uID);
int pID = u.getPart().getId();
Part p = em.find(Part.class, pID);

// Simulate think time to allow parallel threads to find Usrs in parallel.
simulateThinkTimeForSecond(s);
int uCount = u.getCount();
int pAmount = p.getAmount();
// update part
if (u.getUserType() == User.UserType.CONSUMER) {
p.setAmount(pAmount – uCount);
} else {
p.setAmount(pAmount + uCount);
}

try {
em.flush();
} catch (OptimisticLockException e) {
System.out.println(“Got OptimisticLockException while updating with Optimistic Lock. ” +
“The transaction will be rolled back”);
updateSuccessfull = false;
} catch (PersistenceException e ) {
System.out.println(“Got Exception while updating with optimstic lock” + e);
updateSuccessfull = false;
}
return updateSuccessfull;
}

/**
* A find with pessimistic lock followed by some think time, followed by update.
*/
public boolean updateWithPessimisticLock(int uID, int s) {
boolean updateSuccessfull = true;

User u = em.find(User.class, uID);
int pID = u.getPart().getId();
// Using Pessimistic lock to find the part object.
Part p = em.find(Part.class, pID, LockModeType.PESSIMISTIC_WRITE);

// Simulate think time to allow parallel threads to find in parallel.
simulateThinkTimeForSecond(s);
int uCount = u.getCount();
int pAmount = p.getAmount();
// update part
if (u.getUserType() == User.UserType.CONSUMER) {
p.setAmount(pAmount – uCount);
} else {
p.setAmount(pAmount + uCount);
}

try {
em.flush();
} catch (PersistenceException e) {
updateSuccessfull = false;
}
return updateSuccessfull;

}

public void simulateThinkTimeForSecond(int sec) {
//TODO check if sleep is allowed by EE spec
try {
Thread.sleep(sec * 1000);
} catch (Exception ex) {
System.out.println(“get exp in sleep”);
}
}

}

package roster.client;

import java.util.Iterator;
import java.util.List;
import javax.ejb.EJB;
import roster.request.Request;
import roster.util.LeagueDetails;
import roster.util.PlayerDetails;
import roster.util.TeamDetails;

public class RosterClient {
@EJB
private static Request request;

public RosterClient(String[] args) {
}

public static void main(String[] args) {
RosterClient client = new RosterClient(args);

try {
client.insertInfo();
client.getSomeInfo();
client.getMoreInfo();
client.removeInfo();

System.exit(0);
} catch (Exception ex) {
System.err.println(“Caught an exception:”);
ex.printStackTrace();
}
}

private void insertInfo() {
try {
// Leagues
request.createLeague(new LeagueDetails(“L1”, “Mountain”, “Soccer”));
request.createLeague(
new LeagueDetails(“L2”, “Valley”, “Basketball”));
request.createLeague(
new LeagueDetails(“L3”, “Foothills”, “Soccer”));
request.createLeague(
new LeagueDetails(“L4”, “Alpine”, “Snowboarding”));

// Teams
request.createTeamInLeague(
new TeamDetails(“T1”, “Honey Bees”, “Visalia”),
“L1”);
request.createTeamInLeague(
new TeamDetails(“T2”, “Gophers”, “Manteca”),
“L1”);
request.createTeamInLeague(
new TeamDetails(“T5”, “Crows”, “Orland”),
“L1”);

request.createTeamInLeague(
new TeamDetails(“T3”, “Deer”, “Bodie”),
“L2”);
request.createTeamInLeague(
new TeamDetails(“T4”, “Trout”, “Truckee”),
“L2”);

request.createTeamInLeague(
new TeamDetails(“T6”, “Marmots”, “Auburn”),
“L3”);
request.createTeamInLeague(
new TeamDetails(“T7”, “Bobcats”, “Grass Valley”),
“L3”);
request.createTeamInLeague(
new TeamDetails(“T8”, “Beavers”, “Placerville”),
“L3”);

request.createTeamInLeague(
new TeamDetails(“T9”, “Penguins”, “Incline Village”),
“L4”);
request.createTeamInLeague(
new TeamDetails(“T10”, “Land Otters”, “Tahoe City”),
“L4”);

// Players, Team T1
request.createPlayer(“P1”, “Phil Jones”, “goalkeeper”, 100.00);
request.addPlayer(“P1”, “T1”);

request.createPlayer(“P2”, “Alice Smith”, “defender”, 505.00);
request.addPlayer(“P2”, “T1”);

request.createPlayer(“P3”, “Bob Roberts”, “midfielder”, 65.00);
request.addPlayer(“P3”, “T1”);

request.createPlayer(“P4”, “Grace Phillips”, “forward”, 100.00);
request.addPlayer(“P4”, “T1”);

request.createPlayer(“P5”, “Barney Bold”, “defender”, 100.00);
request.addPlayer(“P5”, “T1”);

// Players, Team T2
request.createPlayer(“P6”, “Ian Carlyle”, “goalkeeper”, 555.00);
request.addPlayer(“P6”, “T2”);

request.createPlayer(
“P7”,
“Rebecca Struthers”,
“midfielder”,
777.00);
request.addPlayer(“P7”, “T2”);

request.createPlayer(“P8”, “Anne Anderson”, “forward”, 65.00);
request.addPlayer(“P8”, “T2”);

request.createPlayer(“P9”, “Jan Wesley”, “defender”, 100.00);
request.addPlayer(“P9”, “T2”);

request.createPlayer(“P10”, “Terry Smithson”, “midfielder”, 100.00);
request.addPlayer(“P10”, “T2”);

// Players, Team T3
request.createPlayer(“P11”, “Ben Shore”, “point guard”, 188.00);
request.addPlayer(“P11”, “T3”);

request.createPlayer(
“P12”,
“Chris Farley”,
“shooting guard”,
577.00);
request.addPlayer(“P12”, “T3”);

request.createPlayer(
“P13”,
“Audrey Brown”,
“small forward”,
995.00);
request.addPlayer(“P13”, “T3”);

request.createPlayer(
“P14”,
“Jack Patterson”,
“power forward”,
100.00);
request.addPlayer(“P14”, “T3”);

request.createPlayer(“P15”, “Candace Lewis”, “point guard”, 100.00);
request.addPlayer(“P15”, “T3”);

// Players, Team T4
request.createPlayer(
“P16”,
“Linda Berringer”,
“point guard”,
844.00);
request.addPlayer(“P16”, “T4”);

request.createPlayer(
“P17”,
“Bertrand Morris”,
“shooting guard”,
452.00);
request.addPlayer(“P17”, “T4”);

request.createPlayer(“P18”, “Nancy White”, “small forward”, 833.00);
request.addPlayer(“P18”, “T4”);

request.createPlayer(“P19”, “Billy Black”, “power forward”, 444.00);
request.addPlayer(“P19”, “T4”);

request.createPlayer(“P20”, “Jodie James”, “point guard”, 100.00);
request.addPlayer(“P20”, “T4”);

// Players, Team T5
request.createPlayer(“P21”, “Henry Shute”, “goalkeeper”, 205.00);
request.addPlayer(“P21”, “T5”);

request.createPlayer(“P22”, “Janice Walker”, “defender”, 857.00);
request.addPlayer(“P22”, “T5”);

request.createPlayer(
“P23”,
“Wally Hendricks”,
“midfielder”,
748.00);
request.addPlayer(“P23”, “T5”);

request.createPlayer(“P24”, “Gloria Garber”, “forward”, 777.00);
request.addPlayer(“P24”, “T5”);

request.createPlayer(“P25”, “Frank Fletcher”, “defender”, 399.00);
request.addPlayer(“P25”, “T5”);

// Players, Team T9
request.createPlayer(“P30”, “Lakshme Singh”, “downhill”, 450.00);
request.addPlayer(“P30”, “T9”);

request.createPlayer(“P31”, “Mariela Prieto”, “freestyle”, 420.00);
request.addPlayer(“P31”, “T9”);

// Players, Team T10
request.createPlayer(“P32”, “Soren Johannsen”, “freestyle”, 375.00);
request.addPlayer(“P32”, “T10”);

request.createPlayer(“P33”, “Andre Gerson”, “freestyle”, 396.00);
request.addPlayer(“P33”, “T10”);

request.createPlayer(“P34”, “Zoria Lepsius”, “downhill”, 431.00);
request.addPlayer(“P34”, “T10”);

// Players, no team
request.createPlayer(“P26”, “Hobie Jackson”, “pitcher”, 582.00);
request.createPlayer(“P27”, “Melinda Kendall”, “catcher”, 677.00);

// Players, multiple teams
request.createPlayer(
“P28”,
“Constance Adams”,
“substitute”,
966.00);
request.addPlayer(“P28”, “T1”);
request.addPlayer(“P28”, “T3”);

// Adding existing players to second soccer league
request.addPlayer(“P24”, “T6”);
request.addPlayer(“P21”, “T6”);
request.addPlayer(“P9”, “T6”);
request.addPlayer(“P7”, “T5”);
} catch (Exception ex) {
System.err.println(“Caught an exception:”);
ex.printStackTrace();
}
}

private void getSomeInfo() {
try {
List<PlayerDetails> playerList;
List<TeamDetails> teamList;
List<LeagueDetails> leagueList;

System.out.println(“List all players in team T2:”);
playerList = request.getPlayersOfTeam(“T2”);
printDetailsList(playerList);
System.out.println();

System.out.println(“List all teams in league L1:”);
teamList = request.getTeamsOfLeague(“L1”);
printDetailsList(teamList);
System.out.println();

System.out.println(“List all defenders:”);
playerList = request.getPlayersByPosition(“defender”);
printDetailsList(playerList);
System.out.println();

System.out.println(“List the leagues of player P28”);
leagueList = request.getLeaguesOfPlayer(“P28”);
printDetailsList(leagueList);
System.out.println();
} catch (Exception ex) {
System.err.println(“Caught an exception:”);
ex.printStackTrace();
}
} // getSomeInfo

private void getMoreInfo() {
try {
LeagueDetails leagueDetails;
TeamDetails teamDetails;
PlayerDetails playerDetails;
List<PlayerDetails> playerList;
List<TeamDetails> teamList;
List<LeagueDetails> leagueList;
List<String> sportList;

System.out.println(“Details of league L1:”);
leagueDetails = request.getLeague(“L1”);
System.out.println(leagueDetails.toString());
System.out.println();

System.out.println(“Details of team T3:”);
teamDetails = request.getTeam(“T3”);
System.out.println(teamDetails.toString());
System.out.println();

System.out.println(“Details of player P20:”);
playerDetails = request.getPlayer(“P20”);
System.out.println(playerDetails.toString());
System.out.println();

System.out.println(“List all teams in league L3:”);
teamList = request.getTeamsOfLeague(“L3”);
printDetailsList(teamList);
System.out.println();

System.out.println(“List all players:”);
playerList = request.getAllPlayers();
printDetailsList(playerList);
System.out.println();

System.out.println(“List all players not on a team:”);
playerList = request.getPlayersNotOnTeam();
printDetailsList(playerList);
System.out.println();

System.out.println(“Details of Jack Patterson, a power forward:”);
playerList = request.getPlayersByPositionAndName(
“power forward”,
“Jack Patterson”);
printDetailsList(playerList);
System.out.println();

System.out.println(“List all players in the city of Truckee:”);
playerList = request.getPlayersByCity(“Truckee”);
printDetailsList(playerList);
System.out.println();

System.out.println(“List all soccer players:”);
playerList = request.getPlayersBySport(“Soccer”);
printDetailsList(playerList);
System.out.println();

System.out.println(“List all players in league L1:”);
playerList = request.getPlayersByLeagueId(“L1”);
printDetailsList(playerList);
System.out.println();

System.out.println(
“List all players making a higher salary than Ian Carlyle:”);
playerList = request.getPlayersByHigherSalary(“Ian Carlyle”);
printDetailsList(playerList);
System.out.println();

System.out.println(
“List all players with a salary between 500 and 800:”);
playerList = request.getPlayersBySalaryRange(500.00, 800.00);
printDetailsList(playerList);
System.out.println();

System.out.println(“List all players of team T5:”);
playerList = request.getPlayersOfTeam(“T5”);
printDetailsList(playerList);
System.out.println();

System.out.println(“List all the leagues of player P28:”);
leagueList = request.getLeaguesOfPlayer(“P28”);
printDetailsList(leagueList);
System.out.println();

System.out.println(“List all the sports of player P28:”);
sportList = request.getSportsOfPlayer(“P28”);
printDetailsList(sportList);
System.out.println();
} catch (Exception ex) {
System.err.println(“Caught an exception:”);
ex.printStackTrace();
}
} // getMoreInfo

private void removeInfo() {
try {
System.out.println(“Removing team T6.”);
request.removeTeam(“T6”);
System.out.println();

System.out.println(“Removing player P24”);
request.removePlayer(“P24”);
System.out.println();
} catch (Exception ex) {
System.err.println(“Caught an exception:”);
ex.printStackTrace();
}
}

private static void printDetailsList(List list) {
Iterator i = list.iterator();

while (i.hasNext()) {
Object details = (Object) i.next();

System.out.println(details.toString());
}

System.out.println();
} // printDetailsList
}

package roster.request;

import java.util.List;
import javax.ejb.Remote;
import roster.util.LeagueDetails;
import roster.util.PlayerDetails;
import roster.util.TeamDetails;

@Remote
public interface Request {
void addPlayer(
String playerId,
String teamId);

void createLeague(LeagueDetails leagueDetails);

void createPlayer(
String id,
String name,
String position,
double salary);

void createTeamInLeague(
TeamDetails teamDetails,
String leagueId);

void dropPlayer(
String playerId,
String teamId);

List<PlayerDetails> getAllPlayers();

LeagueDetails getLeague(String leagueId);

List<LeagueDetails> getLeaguesOfPlayer(String playerId);

PlayerDetails getPlayer(String playerId);

List<PlayerDetails> getPlayersByCity(String city);

List<PlayerDetails> getPlayersByHigherSalary(String name);

List<PlayerDetails> getPlayersByLeagueId(String leagueId);

List<PlayerDetails> getPlayersByPosition(String position);

List<PlayerDetails> getPlayersByPositionAndName(
String position,
String name);

List<PlayerDetails> getPlayersBySalaryRange(
double low,
double high);

List<PlayerDetails> getPlayersBySport(String sport);

List<PlayerDetails> getPlayersNotOnTeam();

List<PlayerDetails> getPlayersOfTeam(String teamId);

List<String> getSportsOfPlayer(String playerId);

TeamDetails getTeam(String teamId);

List<TeamDetails> getTeamsOfLeague(String leagueId);

void removeLeague(String leagueId);

void removePlayer(String playerId);

void removeTeam(String teamId);
}

package roster.request;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.ejb.EJBException;
import javax.ejb.Stateful;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import roster.entity.League;
import roster.entity.League_;
import roster.entity.Player;
import roster.entity.Player_;
import roster.entity.SummerLeague;
import roster.entity.Team;
import roster.entity.Team_;
import roster.entity.WinterLeague;
import roster.util.IncorrectSportException;
import roster.util.LeagueDetails;
import roster.util.PlayerDetails;
import roster.util.TeamDetails;

/**
* This is the bean class for the RequestBean enterprise bean.
* @author ian
*/
@Stateful
public class RequestBean implements Request {
private static final Logger logger = Logger.getLogger(
“roster.request.RequestBean”);
private CriteriaBuilder cb;
@PersistenceContext
private EntityManager em;

@PostConstruct
private void init() {
cb = em.getCriteriaBuilder();
}

public void createPlayer(
String id,
String name,
String position,
double salary) {
logger.info(“createPlayer”);

try {
Player player = new Player(id, name, position, salary);
em.persist(player);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public void addPlayer(
String playerId,
String teamId) {
logger.info(“addPlayer”);

try {
Player player = em.find(Player.class, playerId);
Team team = em.find(Team.class, teamId);

team.addPlayer(player);
player.addTeam(team);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public void removePlayer(String playerId) {
logger.info(“removePlayer”);

try {
Player player = em.find(Player.class, playerId);

Collection<Team> teams = player.getTeams();
Iterator<Team> i = teams.iterator();

while (i.hasNext()) {
Team team = i.next();
team.dropPlayer(player);
}

em.remove(player);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

…

public List<PlayerDetails> getPlayersByPosition(String position) {
logger.info(“getPlayersByPosition”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);

// Get MetaModel from Root
//EntityType<Player> Player_ = player.getModel();

// set the where clause
cq.where(
cb.equal(
player.get(Player_.position),
position));
cq.select(player);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<PlayerDetails> getPlayersByHigherSalary(String name) {
logger.info(“getPlayersByHigherSalary”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player1 = cq.from(Player.class);
Root<Player> player2 = cq.from(Player.class);

// Get MetaModel from Root
//EntityType<Player> Player_ = player1.getModel();

// create a Predicate object that finds players with a salary
// greater than player1
Predicate gtPredicate = cb.greaterThan(
player1.get(Player_.salary),
player2.get(Player_.salary));

// create a Predicate object that finds the player based on
// the name parameter
Predicate equalPredicate = cb.equal(
player1.get(Player_.name),
name);
// set the where clause with the predicates
cq.where(gtPredicate, equalPredicate);
// set the select clause, and return only unique entries
cq.select(player1)
.distinct(true);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<PlayerDetails> getPlayersBySalaryRange(
double low,
double high) {
logger.info(“getPlayersBySalaryRange”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);

// Get MetaModel from Root
//EntityType<Player> Player_ = player.getModel();

// set the where clause
cq.where(
cb.between(
player.get(Player_.salary),
low,
high));
// set the select clause
cq.select(player)
.distinct(true);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<PlayerDetails> getPlayersByLeagueId(String leagueId) {
logger.info(“getPlayersByLeagueId”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);
Join<Player, Team> team = player.join(Player_.teams);
Join<Team, League> league = team.join(Team_.league);

// Get MetaModel from Root
//EntityType<Player> Player_ = player.getModel();

// set the where clause
cq.where(
cb.equal(
league.get(League_.id),
leagueId));
cq.select(player)
.distinct(true);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<PlayerDetails> getPlayersBySport(String sport) {
logger.info(“getPlayersByLeagueId”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);
Join<Player, Team> team = player.join(Player_.teams);
Join<Team, League> league = team.join(Team_.league);

// Get MetaModel from Root
//EntityType<Player> Player_ = player.getModel();

// set the where clause
cq.where(
cb.equal(
league.get(League_.sport),
sport));
cq.select(player)
.distinct(true);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<PlayerDetails> getPlayersByCity(String city) {
logger.info(“getPlayersByCity”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);
Join<Player, Team> team = player.join(Player_.teams);

// Get MetaModel from Root
//EntityType<Player> Player_ = player.getModel();

// set the where clause
cq.where(
cb.equal(
team.get(Team_.city),
city));
cq.select(player)
.distinct(true);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<PlayerDetails> getAllPlayers() {
logger.info(“getAllPlayers”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);

cq.select(player);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<PlayerDetails> getPlayersNotOnTeam() {
logger.info(“getPlayersNotOnTeam”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);

// Get MetaModel from Root
//EntityType<Player> Player_ = player.getModel();

// set the where clause
cq.where(cb.isEmpty(player.get(Player_.teams)));
cq.select(player)
.distinct(true);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<PlayerDetails> getPlayersByPositionAndName(
String position,
String name) {
logger.info(“getPlayersByPositionAndName”);

List<Player> players = null;

try {
CriteriaQuery<Player> cq = cb.createQuery(Player.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);

// Get MetaModel from Root
//EntityType<Player> Player_ = player.getModel();

// set the where clause
cq.where(
cb.equal(
player.get(Player_.position),
position),
cb.equal(
player.get(Player_.name),
name));
cq.select(player)
.distinct(true);

TypedQuery<Player> q = em.createQuery(cq);
players = q.getResultList();
}

return copyPlayersToDetails(players);
} catch (Exception ex) {
throw new EJBException(ex);
}
}

public List<LeagueDetails> getLeaguesOfPlayer(String playerId) {
logger.info(“getLeaguesOfPlayer”);

List<LeagueDetails> detailsList = new ArrayList<LeagueDetails>();
List<League> leagues = null;

try {
CriteriaQuery<League> cq = cb.createQuery(League.class);

if (cq != null) {
Root<League> league = cq.from(League.class);

//EntityType<League> League_ = league.getModel();
Join<League, Team> team = league.join(League_.teams);

//EntityType<Team> Team_ = team.getModel();
Join<Team, Player> player = team.join(Team_.players);

cq.where(
cb.equal(
player.get(Player_.id),
playerId));
cq.select(league)
.distinct(true);

TypedQuery<League> q = em.createQuery(cq);
leagues = q.getResultList();
}
} catch (Exception ex) {
throw new EJBException(ex);
}

Iterator<League> i = leagues.iterator();

while (i.hasNext()) {
League league = (League) i.next();
LeagueDetails leagueDetails = new LeagueDetails(
league.getId(),
league.getName(),
league.getSport());
detailsList.add(leagueDetails);
}

return detailsList;
}

public List<String> getSportsOfPlayer(String playerId) {
logger.info(“getSportsOfPlayer”);

List<String> sports = new ArrayList<String>();

try {
CriteriaQuery<String> cq = cb.createQuery(String.class);

if (cq != null) {
Root<Player> player = cq.from(Player.class);
Join<Player, Team> team = player.join(Player_.teams);
Join<Team, League> league = team.join(Team_.league);

// Get MetaModel from Root
//EntityType<Player> Player_ = player.getModel();

// set the where clause
cq.where(
cb.equal(
player.get(Player_.id),
playerId));
cq.select(league.get(League_.sport))
.distinct(true);

TypedQuery<String> q = em.createQuery(cq);
sports = q.getResultList();
}

//        Player player = em.find(Player.class, playerId);
//        Iterator<Team> i = player.getTeams().iterator();
//        while (i.hasNext()) {
//            Team team = i.next();
//            League league = team.getLeague();
//            sports.add(league.getSport());
//        }
} catch (Exception ex) {
throw new EJBException(ex);
}

return sports;
}

…
}

@Id
@GeneratedValue
@Column(name = “SCHOOL_ID”)
private int id;
private String schoolname;

private District district;

private String districtname;

@OneToMany(cascade=CascadeType.ALL, mappedBy=”school”)
private Set<Student> students;
…

@Id
@Column(name = “STUDENT_ID”)
@GeneratedValue
private int id;
private String studentname;
private double grade;

// Bi-directional one-to-many relationship
@ManyToOne(optional = true)
private School school;
…