problem persisting an object with collections and manytomany relationship

Here is my User object:

package com.thompco.persys.dataLib.entity;

import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
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.JoinColumn;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name = "user")
@NamedQueries({
    @NamedQuery(name = "User.findAll", query = "SELECT u FROM User u"),
    @NamedQuery(name = "User.findByUserId",
                query =
                "SELECT u FROM User u WHERE u.userId = :userId"),
    @NamedQuery(name = "User.findByName",
                query =
                "SELECT u FROM User u WHERE u.name = :name"),
    @NamedQuery(name = "User.findByUserName",
                query =
                "SELECT u FROM User u WHERE u.userName = :userName"),
    @NamedQuery(name = "User.findByPassword",
                query =
                "SELECT u FROM User u WHERE u.password = :password")})
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "userId")
    private Long userId;
    @Basic(optional = false)
    @Column(name = "name")
    private String name;
    @Basic(optional = false)
    @Column(name = "userName")
    private String userName;
    @Basic(optional = false)
    @Column(name = "password")
    private String password;
    @ManyToMany(mappedBy = "userCollection")
    private Collection<Datalogger> dataloggerCollection;
    @ManyToMany(mappedBy = "userCollection")
    private Collection<Systempermission> systempermissionCollection;
    @ManyToMany(mappedBy = "userCollection")
    private Collection<Columnheading> columnheadingCollection;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "user")
    private Collection<Columndefinition> columndefinitionCollection;
    @JoinColumn(name = "customerId", referencedColumnName = "customerId")
    @ManyToOne(optional = false)
    private Customer customer;

public User() {
    }

public User(Long userId) {
        this.userId = userId;
    }

public User(Long userId, String name, String userName, String password) {
        this.userId = userId;
        this.name = name;
        this.userName = userName;
        this.password = password;
    }

public Long getUserId() {
        return userId;
    }

public void setUserId(Long userId) {
        this.userId = userId;
    }

public String getName() {
        return name;
    }

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

public String getUserName() {
        return userName;
    }

public void setUserName(String userName) {
        this.userName = userName;
    }

public String getPassword() {
        return password;
    }

public void setPassword(String password) {
        this.password = password;
    }

public Collection<Datalogger> getDataloggerCollection() {
        return dataloggerCollection;
    }

public void setDataloggerCollection(Collection<Datalogger> dataloggerCollection) {
        this.dataloggerCollection = dataloggerCollection;
    }

public Collection<Systempermission> getSystempermissionCollection() {
        return systempermissionCollection;
    }

public void setSystempermissionCollection(Collection<Systempermission> systempermissionCollection) {
        this.systempermissionCollection = systempermissionCollection;
    }

public Collection<Columnheading> getColumnheadingCollection() {
        return columnheadingCollection;
    }

public void setColumnheadingCollection(Collection<Columnheading> columnheadingCollection) {
        this.columnheadingCollection = columnheadingCollection;
    }

public Collection<Columndefinition> getColumndefinitionCollection() {
        return columndefinitionCollection;
    }

public void setColumndefinitionCollection(Collection<Columndefinition> columndefinitionCollection) {
        this.columndefinitionCollection = columndefinitionCollection;
    }

public Customer getCustomer() {
        return customer;
    }

public void setCustomer(Customer customer) {
        this.customer = customer;
    }

@Override
    public int hashCode() {
        int hash = 0;
        hash += (userId != null ? userId.hashCode() : 0);
        return hash;
    }

@Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof User)) {
            return false;
        }
        User other = (User) object;
        if ((this.userId == null && other.userId != null) ||
            (this.userId != null && !this.userId.equals(other.userId))) {
            return false;
        }
        return true;
    }

@Override
    public String toString() {
        return "com.thompco.persys.dataLib.entity.User[userId=" + userId + "]";
    }

}

I get a User(s) from the database:

I update it/them:

public static void convert(final UserTo user, User u, EntityManager em) {
        u.setName(user.actualName);
        u.setPassword(user.password);
        u.setUserName(user.username);
        u.setCustomer(ServerDb.getCustomerId(user.customer, em));

Query query = em.createNamedQuery("Columnheading.findAll");
        List<Columnheading> columnHeadingList = query.getResultList();

u.getColumnheadingCollection().clear();
        for (String userCol : user.columnHeadings) {
            for (Columnheading availCol :columnHeadingList) {
                if (userCol.equals(availCol.getOutputName())) {
                    u.getColumnheadingCollection().add(availCol);
                    break;
                }
            }
        }

Query queryPermissions = em.createNamedQuery("Systempermission.findAll");
        List<Systempermission> permissionList = queryPermissions.getResultList();

u.getSystempermissionCollection().clear();
        for (String userPermission : user.permissions) {
            for (Systempermission availPermission :permissionList) {
                if (userPermission.equals(availPermission.getPermissionName())) {
                    u.getSystempermissionCollection().add(availPermission);
                    break;
                }
            }
        }

Query queryLoggers = em.createNamedQuery("Datalogger.findAll");
        List<Datalogger> loggerList = queryLoggers.getResultList();

u.getDataloggerCollection().clear();
        for (String userLogger : user.loggers) {
            for (Datalogger availLogger :loggerList) {
                if (userLogger.equals(availLogger.getName())) {
                    u.getDataloggerCollection().add(availLogger);
                    break;
                }
            }
        }
    }

And then I save it:

And there is my problem. Everything looks fine until, When I debug the Server, the User (u) looks like it works, but when I refresh it, it reverts back to whatever is in the database before the attempted changes. I did try using merge(u) instead of persist(u), but it made no difference! I thought that if the entity already existed, you NEEDED to call merge().
Note that the user, permissions, dataloggers, columnheadings, etc all exist. All I am doing is trying to make the relationship between them.
Any suggestions?

OK - I'm an idiot. I only updated one way of the many-to-many relationships. You need to update both ends :

u.getDataloggerCollection().clear();
for (String userLogger : user.loggers) {
for (Datalogger availLogger :loggerList) {
if (userLogger.equals(availLogger.getName())) {
u.getDataloggerCollection().add(availLogger);
/** NEED TO ADD THIS: **/
availLogger.getUsers.add(u);
break;
}
}
}

This could be due to use of inverse in the mapping file. In the user mapping file you might have specified inverse="true" for the dataLoggerCollection. This will result in Hibernate ignoring changes to data logger collection in user object.

R_Shehrawat - I'm not sure what you mean by the mapping file...

Anyway, that didn't work either. I have now also tried this new method that updates both the User as well as the collections and persists both sides:

public static boolean persist(final UserTo user, EntityManager em) {
        User u = getUser(user.username, em);

if (u != null) {
            if (!u.getPassword().equals(user.password)) {
                ServerDb.execute("set password for '" + user.username +
                                 "' = password('" + user.password + "')");
            }

u.setName(user.actualName);
            u.setPassword(user.password);
            u.setUserName(user.username);
            u.setCustomer(ServerDb.getCustomerId(user.customer, em));

Query query = em.createNamedQuery("Columnheading.findAll");
            List<Columnheading> columnHeadingList = query.getResultList();

u.getColumnheadingCollection().clear();
            for (Columnheading availCol : columnHeadingList) {
                availCol.getUserCollection().remove(u);

for (String userCol : user.columnHeadings) {
                    if (userCol.equals(availCol.getOutputName())) {
                        u.getColumnheadingCollection().add(availCol);
                        availCol.getUserCollection().add(u);
                        break;
                    }
                }

em.merge(availCol);
            }

Query queryPermissions = em.createNamedQuery(
                    "Systempermission.findAll");
            List<Systempermission> permissionList = queryPermissions.
                    getResultList();

u.getSystempermissionCollection().clear();
            for (Systempermission availPermission : permissionList) {
                availPermission.getUserCollection().remove(u);

for (String userPermission : user.permissions) {
                    if (userPermission.equals(
                            availPermission.getPermissionName())) {
                        u.getSystempermissionCollection().add(availPermission);
                        availPermission.getUserCollection().add(u);
                        break;
                    }
                }

em.merge(availPermission);
            }

Query queryLoggers = em.createNamedQuery("Datalogger.findAll");
            List<Datalogger> loggerList = queryLoggers.getResultList();

u.getDataloggerCollection().clear();
            for (Datalogger availLogger : loggerList) {
                availLogger.getUserCollection().remove(u);

for (String userLogger : user.loggers) {
                    if (userLogger.equals(availLogger.getName())) {
                        u.getDataloggerCollection().add(availLogger);
                        availLogger.getUserCollection().add(u);
                        break;
                    }
                }

em.merge(availLogger);
            }

em.merge(u);
            em.flush();
            return true;
        } else {
            return false;
        }
    }

I am not getting any errors and when I run this code and when I look at the data from the client app, it looks like the code worked... Until I restart the server... the data is only retained in memory on the server and never inserted into the database.
I was mistaken when I said I had it working - the data is temporarily kept in the server until the ejb is re-installed or glassfish is restarted.

My mistake.. i should have looked at the code carefully.. so seems like you are using JPA.. by mapping file i meant hibernate HBM file, which has hibernate specific option inverse="true" which results in the type of behavior you talked about .. (i:e only one side of updates to a relationship are persisted, the other side are ignored for optimization purpose)

R_Shehrawat - thanks for your help. I have searched for any file containing "inverse" in my server project and cannot find one. I also searched for a file called "hibernate" or one called "*.hbm" and could not find any.
For what its worth, here is the ejb handler for a user:

package com.thompco.persys.server.ejb;

import com.thompco.persys.server.helper.ServerDb;
import com.thompco.persys.dataLib.entity.Customer;
import com.thompco.persys.dataLib.entity.User;
import com.thompco.persystransferObject.UserTo;
import com.thompco.persys.server.helper.TransferObjectHelper;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

@WebService()
@Stateless()
public class UserHandler {
    @PersistenceContext(unitName = "ThompCo")
    private EntityManager myEm;

/**
     * Web service operation
     */
    @WebMethod(operationName = "dropUser")
    public Boolean dropUser(@WebParam(name = "username") String username) {
        String sql = "DROP USER '" + username + "'";
        String rtn = ServerDb.execute(sql);

if (rtn == null) {
            sql = "DELETE FROM user WHERE username = '" + username + "'";
            rtn = ServerDb.execute(sql);
            return true;
        }

return false;
    }

/**
     * Web service operation
     */
    @WebMethod(operationName = "getUser")
    public UserTo getUser(@WebParam(name = "username") String username) {
        UserTo rtn = null;
        Query query = myEm.createQuery(
                "SELECT u from User u WHERE u.userName = :userName");
        query.setParameter("userName", username);
        List<User> users = query.getResultList();

if (users.size() > 0) {
            User u = users.get(0);
            UserTo to = TransferObjectHelper.convert(u);
            rtn = to;
        }

return rtn;
    }

/**
     * Web service operation
     */
    @WebMethod(operationName = "updateUser")
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public Boolean updateUser(@WebParam(name = "user") UserTo user) {
        try {
            TransferObjectHelper.persist(user, myEm);
        } catch (Exception e) {
            return false;
        }
        return true;
    }

/**
     * Web service operation
     */
    @WebMethod(operationName = "addUser")
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public Boolean addUser(@WebParam(name = "user") UserTo user) {
        String sql = "CREATE USER '" + user.username + "' IDENTIFIED BY '" +
                     user.password +
                     "'";
        String rtn = ServerDb.execute(sql);
        /**
         * Grant all privileges to this user to the schema.
         * NOTE that "system privileges are controlled by the application.
         */
        if (rtn == null) {
            sql = "GRANT SELECT,INSERT,UPDATE,DELETE ON THOMPCO.* TO '" +
                  user.username + "'@'%'";
            rtn = ServerDb.execute(sql);
            Customer customerEntity =
                     ServerDb.getCustomerId(user.customer, myEm);

if (customerEntity != null) {
                User persistentUser = new User();
                persistentUser.setName(user.actualName);
                persistentUser.setUserName(user.username);
                persistentUser.setCustomer(customerEntity);
                persistentUser.setPassword(user.password);
                myEm.persist(user);
                return true;
            }
        }

return false;
    }

/**
     * Web service operation
     */
    @WebMethod(operationName = "getCustomerUsers")
    public Collection getCustomerUsers(
            @WebParam(name = "customerName") String customerName) {
        Query query =
              myEm.createNamedQuery("Customer.findByName").setParameter("name",
                                                                        customerName);
        List<Customer> customerList = query.getResultList();
        List<UserTo> users = new ArrayList<UserTo>();

if (customerList.size() > 0) {
            for (User u : customerList.get(0).getUserCollection()) {
                users.add(TransferObjectHelper.convert(u));
            }
        }
        return users;
    }
}

Can anyone explain why it updates to memory, but not to the database itself?

thanks,
Jordan

Is the update running in a transaction. I faced similar problem & found that update was not running in a transaction.

No, its not. I tried using a transaction, but got an exception when I tried to create the transaction. From what I found out, it turns out that you cannot mix transactions and @PersistenceContext.