This is an automated email from the ASF dual-hosted git repository.
pcristof pushed a commit to branch OPENJPA-2940
in repository https://gitbox.apache.org/repos/asf/openjpa.git
The following commit(s) were added to refs/heads/OPENJPA-2940 by this push:
new 284a75c8b [OPENJPA-2940][WIP] Implementing PUU.getVersion and
isInstance
284a75c8b is described below
commit 284a75c8b8d3dfe558504969ccd51519ebeff810
Author: Paulo Cristovão de Araújo Silva Filho <[email protected]>
AuthorDate: Fri Jul 18 23:26:52 2025 -0300
[OPENJPA-2940][WIP] Implementing PUU.getVersion and isInstance
* Moved PUU loading tests to test unit already present
* Updated test unit to junit 4.x format
---
.../openjpa/persistence/util/EagerEntity.java | 14 +
.../persistence/util/TestPersistenceUnitUtil.java | 453 ++++++++++++++-------
.../persistence/EntityManagerFactoryImpl.java | 10 +-
.../persistence/OpenJPAPersistenceUtil.java | 20 +
4 files changed, 343 insertions(+), 154 deletions(-)
diff --git
a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/util/EagerEntity.java
b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/util/EagerEntity.java
index f1c940456..307642ae8 100644
---
a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/util/EagerEntity.java
+++
b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/util/EagerEntity.java
@@ -21,6 +21,7 @@ package org.apache.openjpa.persistence.util;
import java.util.List;
import jakarta.persistence.Basic;
+import jakarta.persistence.Column;
import jakarta.persistence.ElementCollection;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
@@ -28,6 +29,7 @@ import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Transient;
+import jakarta.persistence.Version;
@Entity
public class EagerEntity {
@@ -49,6 +51,10 @@ public class EagerEntity {
@OneToMany(fetch=FetchType.EAGER)
private List<EagerEntity> eagerSelf;
+
+ @Version
+ @Column(name = "version_")
+ private Integer version;
@Transient
private String transField;
@@ -100,4 +106,12 @@ public class EagerEntity {
public EagerEmbedRel getEagerEmbedRel() {
return eagerEmbedRel;
}
+
+ public Integer getVersion() {
+ return version;
+ }
+
+ public void setVersion(Integer version) {
+ this.version = version;
+ }
}
diff --git
a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/util/TestPersistenceUnitUtil.java
b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/util/TestPersistenceUnitUtil.java
index e46afb5f9..54924dff2 100644
---
a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/util/TestPersistenceUnitUtil.java
+++
b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/util/TestPersistenceUnitUtil.java
@@ -18,51 +18,80 @@
*/
package org.apache.openjpa.persistence.util;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.sql.Date;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
+import java.util.stream.Stream;
import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import jakarta.persistence.Persistence;
+import jakarta.persistence.PersistenceConfiguration;
import jakarta.persistence.PersistenceUnitUtil;
+import jakarta.persistence.metamodel.Attribute;
import org.apache.openjpa.persistence.OpenJPAEntityManager;
import org.apache.openjpa.persistence.OpenJPAEntityManagerFactorySPI;
import org.apache.openjpa.persistence.OpenJPAPersistence;
-import org.apache.openjpa.persistence.test.SingleEMFTestCase;
-
-public class TestPersistenceUnitUtil extends SingleEMFTestCase{
-
- @Override
- public void setUp() {
- setUp(CLEAR_TABLES, EagerEntity.class, LazyEmbed.class,
- LazyEntity.class, EagerEmbed.class, RelEntity.class,
- EagerEmbedRel.class, MapEntity.class,
- MapKeyEmbed.class, MapValEntity.class,
- OneToEntity.class, ToManyLazy.class, ToManyEager.class);
- }
-
- /*
- * Verifies an entity and its persistent attributes are in the proper
- * load state.
- */
- public void testIsLoadedEager() {
- verifyIsLoadedEagerState(true);
- }
-
- /*
- * Verifies an entity and its persistent attributes are in the proper
- * not loaded state.
- */
- public void testNotLoadedLazy() {
- verifyIsLoadedEagerState(false);
- }
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class TestPersistenceUnitUtil {
+
+ private static EntityManagerFactory emf;
+
+ private EntityManager em;
+
+ @BeforeClass
+ public static void beforeAll() {
+ PersistenceConfiguration conf = new
PersistenceConfiguration("test");
+
conf.property(PersistenceConfiguration.SCHEMAGEN_DATABASE_ACTION,
"drop-and-create");
+ Stream.of(EagerEntity.class, LazyEmbed.class,
+ LazyEntity.class, EagerEmbed.class,
RelEntity.class, EagerEmbedRel.class,
+ MapEntity.class, MapKeyEmbed.class,
MapValEntity.class,
+ OneToEntity.class, ToManyLazy.class,
ToManyEager.class)
+ .forEach(conf::managedClass);
+
+ emf = Persistence.createEntityManagerFactory(conf);
+ }
+
+ /*
+ * Verifies an entity and its persistent attributes are in the proper
load
+ * state.
+ */
+ @Test
+ public void testIsLoadedEager() {
+ verifyIsLoadedEagerState(true);
+ }
+
+ /*
+ * Verifies an entity and its persistent attributes are in the proper
not loaded
+ * state.
+ */
+ @Test
+ public void testNotLoadedLazy() {
+ verifyIsLoadedEagerState(false);
+ }
/*
* Verifies an entity and its persistent attributes are in the proper
* loaded state.
*/
+ @Test
public void testIsLoadedLazy() {
verifyIsLoadedLazyState(true);
}
@@ -71,6 +100,7 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
* Verifies an entity and its persistent attributes are in the proper
* NOT_LOADED state.
*/
+ @Test
public void testNotLoadedEager() {
verifyIsLoadedEagerState(false);
}
@@ -78,19 +108,16 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
/**
* Verifies the use of PersistenceUnitUtil with multiple PU's.
*/
+ @Test
public void testMultiplePUs() {
OpenJPAEntityManagerFactorySPI emf1 =
- (OpenJPAEntityManagerFactorySPI)OpenJPAPersistence.
- createEntityManagerFactory("PUtil1",
- "org/apache/openjpa/persistence/util/" +
- "persistence.xml");
+ (OpenJPAEntityManagerFactorySPI) OpenJPAPersistence.
+
createEntityManagerFactory("PUtil1","org/apache/openjpa/persistence/util/persistence.xml");
assertNotNull(emf1);
OpenJPAEntityManagerFactorySPI emf2 =
- (OpenJPAEntityManagerFactorySPI)OpenJPAPersistence.
- createEntityManagerFactory("PUtil2",
- "org/apache/openjpa/persistence/util/" +
- "persistence.xml");
+ (OpenJPAEntityManagerFactorySPI) OpenJPAPersistence.
+
createEntityManagerFactory("PUtil2","org/apache/openjpa/persistence/util/persistence.xml");
assertNotNull(emf2);
assertNotSame(emf, emf1);
@@ -125,106 +152,15 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
}
- private void verifyPULoadState(EntityManager em,
- PersistenceUnitUtil...puu) {
-
- EagerEntity ee = createEagerEntity();
- assertEquals(false, puu[0].isLoaded(ee));
- assertEquals(false, puu[0].isLoaded(ee,
- "id"));
- assertEquals(false, puu[1].isLoaded(ee));
- assertEquals(false, puu[1].isLoaded(ee,
- "id"));
- assertEquals(false, puu[2].isLoaded(ee));
- assertEquals(false, puu[2].isLoaded(ee,
- "id"));
-
- em.getTransaction().begin();
- em.persist(ee);
- em.getTransaction().commit();
-
- assertEquals(true, puu[0].isLoaded(ee));
- assertEquals(true, puu[0].isLoaded(ee,
- "id"));
- assertEquals(false, puu[1].isLoaded(ee));
- assertEquals(false, puu[1].isLoaded(ee,
- "id"));
- assertEquals(false, puu[2].isLoaded(ee));
- assertEquals(false, puu[2].isLoaded(ee,
- "id"));
- }
-
-
- private void verifyIsLoadedEagerState(boolean loaded) {
- PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
- assertSame(emf, puu);
- EntityManager em = emf.createEntityManager();
- EagerEntity ee = createEagerEntity();
-
- // Vfy LoadState is false for the unmanaged entity
- assertEquals(false, puu.isLoaded(ee));
- assertEquals(false, puu.isLoaded(ee,
- "id"));
-
- em.getTransaction().begin();
- em.persist(ee);
- em.getTransaction().commit();
- em.clear();
-
- if (loaded)
- ee = em.find(EagerEntity.class, ee.getId());
- else
- ee = em.getReference(EagerEntity.class, ee.getId());
-
- assertEquals(loaded, puu.isLoaded(ee));
- assertEquals(loaded, puu.isLoaded(ee, "id"));
- assertEquals(loaded, puu.isLoaded(ee, "name"));
- assertEquals(loaded, puu.isLoaded(ee, "eagerEmbed"));
- assertEquals(false, puu.isLoaded(ee, "transField"));
-
- em.close();
- }
-
- private void verifyIsLoadedLazyState(boolean loaded) {
- PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
- assertSame(emf, puu);
- EntityManager em = emf.createEntityManager();
- LazyEntity le = createLazyEntity();
-
- // Vfy LoadState is false for the unmanaged entity
- assertEquals(false, puu.isLoaded(le));
- assertEquals(false, puu.isLoaded(le,"id"));
-
- em.getTransaction().begin();
- em.persist(le);
- em.getTransaction().commit();
- em.clear();
-
- // Use find or getReference based upon expected state
- if (loaded)
- le = em.find(LazyEntity.class, le.getId());
- else
- le = em.getReference(LazyEntity.class, le.getId());
-
- assertEquals(loaded, puu.isLoaded(le));
- assertEquals(loaded, puu.isLoaded(le, "id"));
-
- // Name is lazy fetch so it should not be loaded
- assertEquals(false, puu.isLoaded(le, "name"));
- assertEquals(loaded, puu.isLoaded(le, "lazyEmbed"));
- assertEquals(false, puu.isLoaded(le, "transField"));
-
- em.close();
- }
-
/*
* Verifies that an entity and attributes are considered loaded if they
* are assigned by the application.
*/
+ @Test
public void testIsApplicationLoaded() {
PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
assertSame(emf, puu);
- EntityManager em = emf.createEntityManager();
+
EagerEntity ee = createEagerEntity();
em.getTransaction().begin();
@@ -245,12 +181,11 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
assertEquals("AppEagerName", ee.getName());
assertEquals(emb, ee.getEagerEmbed());
- em.close();
}
+ @Test
public void testPCMapEager() {
PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
- EntityManager em = emf.createEntityManager();
MapValEntity mve = new MapValEntity();
mve.setIntVal(10);
@@ -261,10 +196,8 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
MapEntity me = new MapEntity();
assertEquals(false, puu.isLoaded(me));
- assertEquals(false, puu.isLoaded(me,
- "mapValEntity"));
- assertEquals(false, puu.isLoaded(me,
- "mapEntities"));
+ assertEquals(false, puu.isLoaded(me,"mapValEntity"));
+ assertEquals(false, puu.isLoaded(me, "mapEntities"));
assertEquals(false, puu.isLoaded(mve));
@@ -272,8 +205,7 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
me.setMapValEntity(mve);
mve.setMapEntity(me);
- HashMap<MapKeyEmbed, MapValEntity> hm =
- new HashMap<>();
+ HashMap<MapKeyEmbed, MapValEntity> hm = new HashMap<>();
hm.put(mke, mve);
me.setMapEntities(hm);
@@ -283,24 +215,20 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
em.getTransaction().commit();
assertEquals(true, puu.isLoaded(me));
- assertEquals(true, puu.isLoaded(me,
- "mapValEntity"));
- assertEquals(true, puu.isLoaded(me,
- "mapEntities"));
+ assertEquals(true, puu.isLoaded(me, "mapValEntity"));
+ assertEquals(true, puu.isLoaded(me, "mapEntities"));
assertEquals(true, puu.isLoaded(mve));
- em.close();
}
/*
* Verify load state is not loaded for null relationships or relationships
* set to null.
*/
+ @Test
public void testSetNullLazyRelationship() {
-
PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
- EntityManager em = emf.createEntityManager();
try {
OneToEntity ote = new OneToEntity();
@@ -349,19 +277,16 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
em.getTransaction().commit();
//Loaded after commit
assertTrue(puu.isLoaded(ote2, "toManyLazy"));
- }
- finally {
+ } finally {
if (em.getTransaction().isActive()) {
em.getTransaction().rollback();
}
}
- em.close();
}
+ @Test
public void testSetNullEagerRelationship() {
-
PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
- EntityManager em = emf.createEntityManager();
try {
OneToEntity ote = new OneToEntity();
@@ -411,15 +336,14 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
em.getTransaction().commit();
//Loaded after commit
assertTrue(puu.isLoaded(ote2, "toManyEager"));
- }
- finally {
+ } finally {
if (em.getTransaction().isActive()) {
em.getTransaction().rollback();
}
}
- em.close();
}
+ @Test
public void testBasicTypeNotLoaded() {
PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
EntityManager em = emf.createEntityManager();
@@ -437,6 +361,211 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
ee = em.find(EagerEntity.class, id);
assertEquals(true, puu.isLoaded(ee));
}
+
+ @Test
+ public void testLoadingLazyAttributeByName() {
+ PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
+
+ LazyEntity e = emf.callInTransaction(em -> {
+ LazyEntity le = createLazyEntity();
+ em.persist(le);
+ return le;
+ });
+
+ assertFalse(puu.isLoaded(e));
+
+ e = em.find(LazyEntity.class, e.getId());
+
+ assertTrue(puu.isLoaded(e));
+ assertTrue(puu.isLoaded(e, "id"));
+ assertFalse(puu.isLoaded(e, "name"));
+ assertFalse(puu.isLoaded(e, "relEntities"));
+
+ puu.load(e, "name");
+ puu.load(e, "relEntities");
+
+ assertTrue(puu.isLoaded(e, "name"));
+ assertTrue(puu.isLoaded(e, "relEntities"));
+
+ }
+
+ @Test
+ public void testLoadingLazyAttribute() {
+ PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
+
+ LazyEntity e = emf.callInTransaction(em -> {
+ LazyEntity le = createLazyEntity();
+ em.persist(le);
+ return le;
+ });
+
+ assertFalse(puu.isLoaded(e));
+
+ e = em.find(LazyEntity.class, e.getId());
+
+ Attribute<? super LazyEntity, ?> attr =
em.getMetamodel().entity(LazyEntity.class).getAttribute("name");
+
+ assertTrue(puu.isLoaded(e));
+ assertTrue(puu.isLoaded(e, "id"));
+ assertFalse(puu.isLoaded(e, attr));
+
+ puu.load(e, attr);
+
+ assertTrue(puu.isLoaded(e, "name"));
+ }
+
+ @Test
+ public void testLoadingUnmanagedEntity() {
+ try {
+ PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
+ LazyEntity e = emf.callInTransaction(em -> {
+ LazyEntity le = createLazyEntity();
+ em.persist(le);
+ return le;
+ });
+ LazyEntity ue = new LazyEntity();
+ ue.setId(e.getId());
+
+ puu.load(ue);
+ fail("Should have thrown IllegalArgumentException");
+ } catch (IllegalArgumentException ex) {
+ assertTrue(ex.getMessage().contains("not persistent"));
+ }
+ }
+
+ @Test
+ public void testLoadingEntity() {
+ PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
+ LazyEntity e = emf.callInTransaction(em -> {
+ LazyEntity le = createLazyEntity();
+ em.persist(le);
+ return le;
+ });
+
+ LazyEntity det = em.getReference(LazyEntity.class, e.getId());
+
+ assertFalse(puu.isLoaded(det));
+ puu.load(det);
+ assertTrue(puu.isLoaded(det));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testUnmanagedEntity() {
+ EagerEntity ee = createEagerEntity();
+ emf.getPersistenceUnitUtil().getVersion(ee);
+ }
+
+ @Test
+ public void testVersionedEntity() {
+ PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
+ EagerEntity e = emf.callInTransaction(em -> {
+ EagerEntity ee = createEagerEntity();
+ em.persist(ee);
+ assertNull(puu.getVersion(ee));
+ return ee;
+ });
+ e = em.find(EagerEntity.class, e.getId());
+ int v1 = (int) puu.getVersion(e);
+ assertEquals(1, v1);
+ em.getTransaction().begin();
+ e.setName("Changed name");
+ e = em.merge(e);
+ em.getTransaction().commit();
+
+ assertEquals(2, (int) puu.getVersion(e));
+ }
+
+ @Test
+ public void testUnversionedEntity() {
+ PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
+ LazyEntity e = emf.callInTransaction(em -> {
+ LazyEntity le = createLazyEntity();
+ em.persist(le);
+ assertNull(puu.getVersion(le));
+ return le;
+ });
+ e = em.find(LazyEntity.class, e.getId());
+ assertNull(puu.getVersion(e));
+ }
+
+ private void verifyIsLoadedEagerState(boolean loaded) {
+ PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
+ assertSame(emf, puu);
+
+ EagerEntity ee = createEagerEntity();
+
+ assertFalse(puu.isLoaded(ee));
+ assertFalse(puu.isLoaded(ee, "id"));
+
+ em.getTransaction().begin();
+ em.persist(ee);
+ em.getTransaction().commit();
+ em.clear();
+
+ if (loaded) {
+ ee = em.find(EagerEntity.class, ee.getId());
+ } else {
+ ee = em.getReference(EagerEntity.class, ee.getId());
+ }
+
+ assertEquals(loaded, puu.isLoaded(ee));
+ assertEquals(loaded, puu.isLoaded(ee, "id"));
+ assertEquals(loaded, puu.isLoaded(ee, "name"));
+ assertEquals(loaded, puu.isLoaded(ee, "eagerEmbed"));
+ assertFalse(puu.isLoaded(ee, "transField"));
+ }
+
+ private void verifyIsLoadedLazyState(boolean loaded) {
+ PersistenceUnitUtil puu = emf.getPersistenceUnitUtil();
+ assertSame(emf, puu);
+ LazyEntity le = createLazyEntity();
+
+ // Vfy LoadState is false for the unmanaged entity
+ assertEquals(false, puu.isLoaded(le));
+ assertEquals(false, puu.isLoaded(le,"id"));
+
+ em.getTransaction().begin();
+ em.persist(le);
+ em.getTransaction().commit();
+ em.clear();
+
+ // Use find or getReference based upon expected state
+ if (loaded)
+ le = em.find(LazyEntity.class, le.getId());
+ else
+ le = em.getReference(LazyEntity.class, le.getId());
+
+ assertEquals(loaded, puu.isLoaded(le));
+ assertEquals(loaded, puu.isLoaded(le, "id"));
+
+ // Name is lazy fetch so it should not be loaded
+ assertEquals(false, puu.isLoaded(le, "name"));
+ assertEquals(loaded, puu.isLoaded(le, "lazyEmbed"));
+ assertEquals(false, puu.isLoaded(le, "transField"));
+
+ em.close();
+ }
+
+ private void verifyPULoadState(EntityManager em, PersistenceUnitUtil...
puu) {
+ EagerEntity ee = createEagerEntity();
+ assertEquals(false, puu[0].isLoaded(ee));
+ assertEquals(false, puu[0].isLoaded(ee, "id"));
+ assertEquals(false, puu[1].isLoaded(ee));
+ assertEquals(false, puu[1].isLoaded(ee, "id"));
+ assertEquals(false, puu[2].isLoaded(ee));
+ assertEquals(false, puu[2].isLoaded(ee, "id"));
+
+ em.getTransaction().begin();
+ em.persist(ee);
+ em.getTransaction().commit();
+
+ assertEquals(true, puu[0].isLoaded(ee));
+ assertEquals(true, puu[0].isLoaded(ee, "id"));
+ assertEquals(false, puu[1].isLoaded(ee));
+ assertEquals(false, puu[1].isLoaded(ee, "id"));
+ assertEquals(false, puu[2].isLoaded(ee));
+ assertEquals(false, puu[2].isLoaded(ee, "id"));
+ }
private EagerEntity createEagerEntity() {
EagerEntity ee = new EagerEntity();
@@ -477,4 +606,24 @@ public class TestPersistenceUnitUtil extends
SingleEMFTestCase{
assertEquals(state, pu.isLoaded(ent, "eagerEmbed"));
assertEquals(false, pu.isLoaded(ent, "transField"));
}
+
+ @AfterClass
+ public static void afterAll() {
+ if (emf != null && emf.isOpen()) {
+ emf.close();
+ }
+ }
+
+ @Before
+ public void beforeEach() {
+ em = emf.createEntityManager();
+ }
+
+ @After
+ public void afterEach() {
+ if (em != null && em.isOpen()) {
+ em.close();
+ }
+ }
+
}
diff --git
a/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerFactoryImpl.java
b/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerFactoryImpl.java
index 78bf79a37..71bb288bc 100644
---
a/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerFactoryImpl.java
+++
b/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerFactoryImpl.java
@@ -573,12 +573,18 @@ public class EntityManagerFactoryImpl
@Override
public Object getVersion(Object entity) {
- throw new UnsupportedOperationException("Not yet implemented (JPA
3.2)");
+ if (!OpenJPAPersistenceUtil.isManagedBy(this, entity)) {
+ throw new
IllegalArgumentException(_loc.get("invalid_entity_argument",
+ "load", entity == null ? "null" :
Exceptions.toString(entity)).getMessage());
+ }
+ return OpenJPAPersistenceUtil.getVersion(this, entity);
}
@Override
public boolean isInstance(Object entity, Class<?> entityClass) {
- throw new UnsupportedOperationException("Not yet implemented (JPA
3.2)");
+ return entity != null && entityClass != null
+ && OpenJPAPersistenceUtil.isManagedBy(this, entity)
+ && entityClass.isAssignableFrom(entity.getClass());
}
@Override
diff --git
a/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/OpenJPAPersistenceUtil.java
b/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/OpenJPAPersistenceUtil.java
index d6ddddb00..e60e00d86 100644
---
a/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/OpenJPAPersistenceUtil.java
+++
b/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/OpenJPAPersistenceUtil.java
@@ -76,6 +76,26 @@ public class OpenJPAPersistenceUtil {
}
return null;
}
+
+ /**
+ * Get version of a persistent entity managed by one of the
+ * entity managers of the specified entity manager factory.
+ *
+ * @param emf the entity manager factory presumed to contain the given
entity
+ * @param entity the entity whose version is desired
+ * @return the version of the entity, or null if it does not have a
version field
+ * or if it was not persisted yet.
+ *
+ */
+ public static Object getVersion(OpenJPAEntityManagerFactory emf, Object
entity) {
+ if (entity instanceof PersistenceCapable pc) {
+ StateManager sm = pc.pcGetStateManager();
+ if (sm != null && sm instanceof OpenJPAStateManager osm) {
+ return osm.getVersion();
+ }
+ }
+ return null;
+ }
/**
* Determines whether the specified state manager is managed by an open
