Question

I am attempting to update an existing record using JPA. The following link seems to suggest that the only way to update a record would be to write the update query for it
enter link description here

Which is fine. But again, I am wondering why am I pulling this out of stored proc to use all f the magic of open JPA?
I thought that If I had an instance of a JPA object that if I tried to persist to the database using a call similar to this

emf.persist(launchRet)

the JPA framework would check to see if the record allready exists, if so, it would then proceed to make the changes to that record, if not, it would just add a new record. Which would be really cool. Instead, I am going to have to end up writing all that logic myself in an update query. Which is fine, But why can’t I just use a stored proc and just pass it all the necessary values?

UPDATE: CODE EXPLAINING WHAT MY LAST COMMENT IS ALL ABOUT

    try{
        launchRet = emf.find(QuickLaunch.class, launch.getQuickLaunchId());
        if(launchRet==null){                
            emf.getTransaction().begin();
            emf.persist(launchRet);
            emf.getTransaction().commit();
        }
        else{
            emf.refresh(launchRet);
        }
    }

The variable launch is passed into the method…

public QuickLaunch UpdateQuickLaunchComponent(QuickLaunch launch) 

Would I simple just set the found launch launchRet equal to the launch that was passed in?

Answer 1

Read the link that you posted:

You can modify an entity instance in one the following ways:

• Using an Updating Query
• Using the Entity’s Public API
  […]

The way used in 99% of the cases is the second way:

Foo someExistingFoo = em.find(Foo.class, someExistingFooId);
someExistingFoo.setSomeValue(theNewValue);
// no need to call any persist method: the EM will flush the new state 
// of the entity to the database when needed

Of course, the entity can also be loaded via a query, or by navigating through the graph of entities.

If you have a detached entity, and you want to persist its state to the database, use the EntityManager.merge() method. It finds the entity with the same ID as the detached one passed as argument, copies the state from the detached entity to the attached one, and returns the attached one:

Foo attachedModifiedFoo = em.merge(detachedFoo);

If the detached entity isn’t persistent (i.e. doesn’t have any ID), then it is created and made persistent.