Hibernate inserts optimization when there is relationship @ManyToMany

  

This is because Hibernate supports an additional feature of a collection called Bag . A Bag is a collection that may have duplicate members, but is not ordered. The best feature of a Bag is that you can get the number of occurrences of an object through the API using the public int occurrences(Object o) method.

     

In List , there is no way to do the same without iterating through all its elements.

     

So when a List is mapped without a column for indexing, Hibernate treats it as a Bag . In essence, a List that has a column for indexing is Bag indexed.

     

With Hibernate treating List as a Bag , it believes that there may be duplicate elements in the join table. Also, it knows that the elements in the join table are not ordered. So, there is no way to know which lines should be deleted from the object in java.

     

Then Hibernate needs to continue and re-insert all the lines it knows from java that should not be deleted.

     

If you do not need duplicate objects, you can use Set . A Set does not need a column for indexing, and Hibernate can distinguish a row from its table because it knows that a Set has no duplicate elements.

Source

That is, either you use a column to sort your join table, or use Set instead of List . In case you keep List it would look like this:

Permission:

@Entity
public class Permission {

    @Id
    private int id;

    @OrderColumn(name="order_id")
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<User> users;

    public Permission() {}

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

    public int getId() {
        return id;
    }

    public List<User> getUsers() {
        return users;
    }

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

User:

@Entity
public class User {

    @Id
    private int id;

    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "users")
    private List<Permission> permissions;

    public User() {}

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

    public List<Permission> getPermissions() {
        return permissions;
    }

    public void setPermissions(List<Permission> permissions) {
        this.permissions = permissions;
    }
}

Test:

public class Teste {

    public static void main(String[]args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("pt-stackoverflow");
        EntityManager em = emf.createEntityManager();

        em.getTransaction().begin();

        User u = em.find(User.class, 1);

        int permissions[] = {1, 2};

        for(int permission : permissions) {
            Permission p = em.find(Permission.class, permission);
            p.getUsers().add(u);
        }

        em.getTransaction().commit();

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

With the annotation:

  

select user0_.id as id1_2_0_ from User user0_ where user0_.id =?

     

select permission0_.id as id1_0_0_ from Permission permission0_ where permission0_.id =?

     

select users0_.permissions_id as permissi1_1_0_, users0_.users_id as users_id2_1_0_, users0_.permissions_id_index_column as permissi3_0_, user1_.id as id1_2_1_ from Permission_User users0_ inner join User user1_ on users0_.users_id = user1_.id where users0_.permissions_id =?

     

select permission0_.id as id1_0_0_ from Permission permission0_ where permission0_.id =?

     

select users0_.permissions_id as permissi1_1_0_, users0_.users_id as users_id2_1_0_, users0_.permissions_id_index_column as permissi3_0_, user1_.id as id1_2_1_ from Permission_User users0_ inner join User user1_ on users0_.users_id = user1_.id where users0_.permissions_id =?

     

insert into Permission_User (permissions_id, permissions_id_index_column, users_id) values (?,?,?)

     

insert into Permission_User (permissions_id, permissions_id_index_column, users_id) values (?,?,?)

No DELETE !