Exception while deleting a Entity

[krishna bulusu]

Hi Folks,
I have the following Bean code:

@Stateful
@Remote(CompanyInterface.class)
public class CompanyBean implements CompanyInterface {
@PersistenceContext(type=PersistenceContextType.TRANSACTION)
private EntityManager entity;
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void deleteEmployee(Employee emp) throws Exception{
if(emp == null)
throw new Exception("can not delete null Employee");
entity.remove(entity.merge(emp));
}

My client code is as follows:

public class CompanyClient {
public static void main(String[] args) throws Exception {
Context ctx = new InitialContext();
CompanyInterface company = (CompanyInterface) ctx.lookup("CompanyBean/remote");
if(company != null)
System.out.println("Mil gaya Company!!!!!!");
Employee employee = company.findEmployee(2);
System.out.println(employee.getName());
//employee.setSalary(40000l);
company.deleteEmployee(employee);
System.out.println("Hurrey..........deleted Employee");
}
}
    

When excecuting the above client, I am getting the following exception:
javax.persistence.EntityNotFoundException: deleted entity passed to persist: [bala.persistent.Employee#<null>]
(same the case with sateless session bean in the above case)

If I make the following change for PersistenceContext it works fine:
@PersistenceContext(type=PersistenceContextType.EXTENDED)

Could anyone explain why this behaviour?

[E Lievaart]

Hmm, that's strange since you're calling merge on it first.
It should be all right.

The entity does exist in the database right?
Does deleting the entity violate a FK constraint somewhere?

What happens if you use:
entity.remove(entity.getReference(emp.getPK()));

instead of:
entity.remove(entity.merge(emp));

[Sergio Tridente]

Make sure the entity actually exists in the database. I have tried the code you posted (with some modifications) and everything worked fine.

This is my implementation of CopmpanyBean (I just added the insertEmployee() business method):

@Stateful(name="com.business.CompanyInterface")
public class CompanyBean implements CompanyInterface {
@PersistenceContext(unitName="javaranch", type=PersistenceContextType.TRANSACTION)
private EntityManager entity;
 
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void insertEmployee(Employee emp) throws Exception {
if(emp == null)
throw new Exception("can not insert null Employee");
entity.persist(emp);
}
 
public Employee findEmployee(Long id) throws Exception {
return entity.find(Employee.class, id);
}
 
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void deleteEmployee(Employee emp) throws Exception {
if(emp == null)
throw new Exception("can not delete null Employee");
entity.remove(entity.merge(emp));
}
}

And here's my client's code:

public class CompanyClient
{
public static void main(String[] args) throws Exception {
try {
final Context jndiContext = new InitialContext();
CompanyInterface company = (CompanyInterface)jndiContext.lookup("com.business.CompanyInterface");
if(company != null)
System.out.println("Mil gaya Company!!!!!!");
 
Employee employee = new Employee();
employee.setId((long)2);
employee.setName("Filiberto Contreras");
company.insertEmployee(employee);
 
employee = company.findEmployee((long)2);
System.out.println(employee.getName());
company.deleteEmployee(employee);
System.out.println("Hurrey..........deleted Employee");
 
} catch(NamingException ne) {
ne.printStackTrace();
}
}
}

As you can see, I have simply added some code to make sure the employee exists.
Can you tell us in what circumstances you are running the example?

[krishna bulusu]

If you observe closely my client code. I am printing the company name after the retrieval of the company entity from the database. It works simply fine if I am changing the persistent context type to extended.
I am posting the Employee Bean:

package bala.persistent;
 
import java.io.Serializable;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
@Entity
@NamedQuery(name="findAllEmps", query="SELECT e from Employee e")
public class Employee implements Serializable{

/**
 * 
 */
private static final long serialVersionUID = 1L;
int ID;
String name;
Long salary;
Manager manager;

public Employee(){
}
@Id
@Column(name="Employee_Id")
@GeneratedValue(strategy=GenerationType.AUTO)
public int getID() {
return ID;
}
 
public void setID(int id) {
ID = id;
}

@ManyToOne
@JoinColumn(name = "Manager_Id", referencedColumnName = "Manager_Id")
public Manager getManager() {
return manager;
}
 
public void setManager(Manager manager) {
this.manager = manager;
}
 
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;
}
}

[krishna bulusu]

More over, If the entity doesn't existing in the database, I think the system throws Entity doesn't existing exception upon deleting the entity rather than the exception I posted earlier.

[krishna bulusu]

Hi E Lievaart,
It is working fine If I am using the following method instead of merge:

entity.remove(entity.getReference(Employee.class, emp.getID()));
    

And another thing is that, I have a manager entity which has one-to-many relation with the employee.
followig is the code:

 
package bala.persistent;
 
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.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
 

@Entity
@NamedQuery(name="findAllManagers",query="SELECT m from Manager m")
public class Manager implements Serializable{

/**
 * 
 */
private static final long serialVersionUID = 1L;
private int id;
private String name;
private Long salary;
private List Employees;
public Manager(){
}

@OneToMany(mappedBy = "manager", cascade = CascadeType.ALL, targetEntity=Employee.class)
public List getEmployees() {
return Employees;
}

@Id
@Column(name="Manager_Id")
@GeneratedValue(strategy=GenerationType.AUTO)
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 void setEmployees(List employees) {
Employees = employees;
}
}
 
   

If I am trying to delete the manager useing the following code, it simply working fine but the same code is not working for the employee entity.

  
public void deleteManager(Manager mng) throws Exception{
if(mng == null)
throw new Exception("can not delete null manager");
entity.remove(entity.merge(mng));
}
  

can you throw some light on it?

[E Lievaart]

Hey Krishna,

My best guess here is that you get the exception due to a FK constraint.
In JPA it is the programmers job to ensure the references are valid.
Try setting the references to null after you merge, before you remove.
So set Employee.manager to null and remove the Employee from Manager.employees.

[Sergio Tridente]

Hi Krishna,

I agree with E Lievaart. You must be performing the actions in the wrong order.

I have tried again with both entities and everything is working fine. Could you please post your complete bean's and client's code?

[krishna bulusu]

If it is FK constraint problem, then system would throws the same exception.
I habe already posted the entities code.
I am posting the Bean and the client code.
I am using JBoss 4.2.2 server.

Client code:

package bala.client;
 
import java.util.ArrayList;
import java.util.List;
 
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
 
import bala.business.CompanyInterface;
import bala.persistent.Employee;
import bala.persistent.Manager;
 
public class CompanyClient {
public static void main(String[] args) throws Exception {
Context ctx = new InitialContext();
CompanyInterface company = (CompanyInterface) ctx.lookup("CompanyBean/remote");
if(company != null)
System.out.println("Mil gaya Company!!!!!!");

Employee emp = company.findEmployee(9);
System.out.println(emp.getName());
company.deleteEmployee(emp);
System.out.println("Hurrey..........deleted employee");

}
}
    

Beans code:

 
package bala.business;
 
import java.util.List;
 
import javax.annotation.Resource;
import javax.ejb.Remote;
import javax.ejb.SessionContext;
import javax.ejb.Stateful;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.PersistenceContextType;
import javax.persistence.Query;
 
import bala.persistent.Employee;
import bala.persistent.Manager;
 
@Stateful
@Remote(CompanyInterface.class)
public class CompanyBean implements CompanyInterface {
@PersistenceContext(type=PersistenceContextType.TRANSACTION)
private EntityManager entity;

public Employee addEmployee(Employee emp) {
if(emp == null)
emp = new Employee();
entity.persist(emp);
return emp;
}
 
public Manager addManager(Manager mng) {
if(mng == null)
mng = new Manager();
entity.persist(mng);
return mng;
}
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void deleteEmployee(Employee emp) throws Exception{
if(emp == null)
throw new Exception("can not delete null Employee");
entity.remove(entity.merge(emp));
}
 
public void deleteManager(Manager mng) throws Exception{
if(mng == null)
throw new Exception("can not delete null manager");
entity.remove(entity.merge(mng));
}
 
public List getAllEmployees() {
Query query = entity.createNamedQuery("findAllEmps");
return query.getResultList();
}
 
public List getAllManagers() {
Query query = entity.createNamedQuery("findAllManagers");
return query.getResultList();
}
 
public Employee findEmployee(int accNo) {
Employee emp = entity.find(Employee.class, accNo);
if(emp != null)
return emp;
return null;
}
 
public Manager findManager(int accNo) {
Manager mng = entity.find(Manager.class, accNo);
if(mng != null)
return mng;
return null;
}
}
   

Try it your self and let me know the result.

[Sergio Tridente]

Hi Krishna,

I finally got an exception. Let me explain what I did.

At the beginning my client was doing the following:
1) Insert manager
2) Insert employee
3) Delete employee
4) Delete manager

Everething in the same client execution: I did not get any errors.

At a given time and after trying several combinations, I got the following exception: javax.persistence.EntityExistsException (Cannot persist detached object). This is what I did:
1) Insert the manager
2) Insert the client
3) Delete the client
At this point my client execution finished, and in the next execution I tried to:
4) Insert the client ---> EntityExistsException

it works fine after changing the bean in the following way:

@Stateful
@Remote(CompanyInterface.class)
public class CompanyBean implements CompanyInterface {
@PersistenceContext(type=PersistenceContextType.TRANSACTION)
private EntityManager entity;

public Employee addEmployee(Employee emp) {
if(emp == null)
emp = new Employee();
[B]if(emp.getManager() != null) {
Manager mgr = entity.merge(emp.getManager());
mgr.getEmployees().add(emp);
}[/B]
entity.persist(emp);
return emp;
}
 
public Manager addManager(Manager mng) {
if(mng == null)
mng = new Manager();
entity.persist(mng);
return mng;
}
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void deleteEmployee(Employee emp) throws Exception{
if(emp == null)
throw new Exception("can not delete null Employee");
[B]if(emp.getManager() != null) {
Manager mgr = entity.merge(emp.getManager());
mgr.getEmployees().remove(emp);
}[/B]
entity.remove(entity.merge(emp));
}
 
public void deleteManager(Manager mng) throws Exception{
if(mng == null)
throw new Exception("can not delete null manager");
entity.remove(entity.merge(mng));
}
}

I also needed to implement the equals() method in the Employee class (to make List.remove() work properly);

Try the changes I am proposing and tell me if it works OK.
[ July 22, 2008: Message edited by: Sergio Tridente ]