Stuck on manyToMany association

[Nonni Singh]

Hello Ranchers,
I'm stuck on an issue related to manyToMany association. Not sure, whether anything wrong with the mapping or is the behavior of hibernate, which is very unlikely. Any help will be appreciated.

I've 2 entities Category & Product, and a Join table "CATEGORY_PRODUCT", which has Category_id (from category table) and Product_id (from product table) columns. In my test method, trying to create association between existing entities(Category & Product), and on transaction commit, it does create association, but on console, I'm seeing hibernate is running delete query against the CATEGORY_PRODUCT table removing category records, for which I'm creating new association.

Q: Why hibernate is executing delete and how to avoid this call?

@Entity
@Table(name = "CATEGORY")
public class Category implements java.io.Serializable {
 
	private static final long serialVersionUID = 3877766424160635530L;
	
	@Id
	@SequenceGenerator(name = "CATEGORY_GEN", sequenceName = "CATEGORY_SEQ")
	@GeneratedValue(generator = "CATEGORY_GEN")
	@Column(name = "CATEGORY_ID")
	private Long categoryId;
	private String name;
	
	@Column(name = "DESCRIPTION")
	private String desc;
	
	@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
	@JoinTable(name = "CATEGORY_PRODUCT", 
			   joinColumns = { @JoinColumn(name = "CATEGORY_ID", nullable = false, updatable = false) }, 
			   inverseJoinColumns = { @JoinColumn(name = "PRODUCT_ID", nullable = false, updatable = false) })
	private List<Product> products;
 
	public Category() {
	}
 
	public Category(String name, String desc) {
		this.name = name;
		this.desc = desc;
	}
 
 
	public Long getCategoryId() {
		return this.categoryId;
	}
 
	public void setCategoryId(Long categoryId) {
		this.categoryId = categoryId;
	}
 
	public String getName() {
		return this.name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public String getDesc() {
		return this.desc;
	}
 
	public void setDesc(String desc) {
		this.desc = desc;
	}
 
	public List<Product> getProducts() {
		return this.products;
	}
 
	public void setProducts(List<Product> products) {
		this.products = products;
	}
 
}

@Entity
@Table(name = "PRODUCT")
public class Product implements java.io.Serializable {

	private static final long serialVersionUID = 4152127362246131799L;

	@Id
	@SequenceGenerator(name = "PRODUCT_GEN", sequenceName = "PRODUCT_SEQ")
	@GeneratedValue(generator = "PRODUCT_GEN")
	@Column(name = "PRODUCT_ID")
	private Long productId;

	@Column(name = "PRODUCT_CODE")
	private String productCode;

	private String name;

	@ManyToMany(fetch = FetchType.LAZY, mappedBy = "products")
	private List<Category> categories;

	public Product() {
	}

	public Product(String stockCode, String stockName) {
		this.productCode = stockCode;
		this.name = stockName;
	}


	public Long getProductId() {
		return this.productId;
	}

	public void setProductId(Long productId) {
		this.productId = productId;
	}

	public String getStockCode() {
		return this.productCode;
	}

	public void setStockCode(String stockCode) {
		this.productCode = stockCode;
	}

	public String getStockName() {
		return this.name;
	}

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

	public List<Category> getCategories() {
		return this.categories;
	}

	public void setCategories(List<Category> categories) {
		this.categories = categories;
	}

}

public class TestCase {

	private static Logger log = Logger.getLogger(TestCase.class);

	public static void main(String[] args) {

		EntityManagerFactory emf = Persistence.createEntityManagerFactory("JPAService");
		EntityManager em = emf.createEntityManager();
		
		em.getTransaction().begin();
		
	
		Product p = em.find(Product.class, new Long(4));
		Category c = em.find(Category.class, new Long(1));
		
		List<Product> products = new ArrayList<Product>();
		products.add(p);
		c.setProducts(products);
		
		
		em.getTransaction().commit();
		
		log.debug("Closing Entity Manager");
		em.close();
		emf.close();
	}

}

Queries from console:
Hibernate: select product0_.PRODUCT_ID as PRODUCT1_4_0_, product0_.name as name4_0_, product0_.PRODUCT_CODE as PRODUCT3_4_0_ from PRODUCT product0_ where product0_.PRODUCT_ID=?
Hibernate: select category0_.CATEGORY_ID as CATEGORY1_0_0_, category0_.DESCRIPTION as DESCRIPT2_0_0_, category0_.name as name0_0_ from CATEGORY category0_ where category0_.CATEGORY_ID=?
Hibernate: delete from CATEGORY_PRODUCT where CATEGORY_ID=?
Hibernate: insert into CATEGORY_PRODUCT (CATEGORY_ID, PRODUCT_ID) values (?, ?)

[Hebert Coelho]

Try removing the Cascade from: @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)

PS.: On a @ManyToMany you do not need to set the fetch as Lazy, it is the default implementation. [=

[Nonni Singh]

Removing Cascade will not avoid delete call, but will increase the number of persist call, in below scenario

Scenario: Create new Category & Product entities and save.
Without Cascade: Need to call persist on category, as well on product.

Product p = new Product("P.201", "Jungle Book");
em.persist(p);		

List<Product> products = new ArrayList<Product>();
products.add(p);
		
Category c = new Category("Children's Book", "Children's Book", products); 
em.persist(c);

With Cascade: Need to call persist only on category, which in turn will save Product & relationship

Product p = new Product("P.201", "Jungle Book");
		
List<Product> products = new ArrayList<Product>();
products.add(p);

Category c = new Category("Children's Book", "Children's Book", products); 
em.persist(c);

To me delete query make sense, only when Category_id & Product_id (which are primary & foreign keys) are part of where clause.

[Frits Walraven]

Hi Nonni,

Q: Why hibernate is executing delete and how to avoid this call?

I tried your example and in my setup Hibernate is only running the delete query if there is an existing relationship in de the Category_Product table between Category(1) and another Product (other than 4).

Does you Category (1) have an existing relationship before you make the update?

Regards,
Frits

[Nonni Singh]

Thanks Frits for trying the scenario.
Yes, the join table (Category_Product) has existing entries for Category (1). Firing delete before insertion is fine, but both tables primary key should be in where clause, or one has re-insert existing records while trying to add new Products relationship for same Category (1).

[Frits Walraven]

Firing delete before insertion is fine, but both tables primary key should be in where clause, or one has re-insert existing records while trying to add new Products relationship for same Category (1).

Yes, you are right: when I add products to the Category(1), it deletes the existing rows in the Category_Product table and (re-)inserts the new as well as the existing rows... (this behavior is the same if I update the name of an existing product of the Category(1) and merge the it into the database)

Probably something hibernate specific, however I can't think of a logical explanation for this behavior.

Regards,
Frits