pmf = JDOHelper.getPersistenceManagerFactory(prop); } else { try { dsProperties.put(ConfVars.MANAGER_FACTORY_CLASS.getVarname(), "org.datanucleus.api.jdo.JDOPersistenceManagerFactory"); pmf = JDOHelper.getPersistenceManagerFactory(dsProperties); } catch (SQLException e) { LOG.warn("Could not create PersistenceManagerFactory using " + "connection pool properties, will fall back", e); pmf = JDOHelper.getPersistenceManagerFactory(prop);
public boolean objectExists( Object object ) { return ( JDOHelper.getObjectId( object ) != null ); }
/** * Accessor for whether the passed object is detached. * @param obj The object * @return Whether it is detached */ public boolean isDetached(Object obj) { // Relay through to JDOHelper - TODO Change this when we JPOX-JPA doesnt depend on JDO return JDOHelper.isDetached(obj); }
/** * Returns a named {@link PersistenceManagerFactory} or persistence * unit. * * @since 2.1 * @see #getPersistenceManagerFactory(Map,String,ClassLoader,ClassLoader) */ public static PersistenceManagerFactory getPersistenceManagerFactory (Map<?, ?> overrides, String name) { ClassLoader cl = getContextClassLoader(); return getPersistenceManagerFactory(overrides, name, cl, cl); }
if (isDetached(pc)) { if (isDirty(pc)) { if (isPersistent(pc)) { if (isTransactional(pc)) { if (isDirty(pc)) { if (isNew(pc)) { if (isDeleted(pc)) { if (isDeleted(pc)) { if (isDirty(pc)) { if (isTransactional(pc)) { if (isDirty(pc)) {
ZooJdoProperties props = new ZooJdoProperties(TestTools.getDbName()); PersistenceManagerFactory pmf = JDOHelper.getPersistenceManagerFactory(props); TestTools.defineSchema(TestSuper.class); PersistenceManager pm1 = pmf.getPersistenceManager(); Object f = ((JDOOptimisticVerificationException)t).getFailedObject(); assertTrue(f instanceof ZooHandle); failedOids.add(JDOHelper.getObjectId(f)); pm1.currentTransaction().begin(); assertTrue(JDOHelper.isDeleted(t21)); assertTrue(JDOHelper.isDeleted(t22)); assertEquals(23+1000, t23.getAttrLong("_id")); assertEquals(14, t24.getAttrLong("_id")); assertTrue(JDOHelper.isDeleted(t25));
if (!JDOHelper.isPersistent(value)) if (JDOHelper.isDetached(value)) Object obj = pm.getObjectById(JDOHelper.getObjectId(value), true, false, value.getClass().getName()); if (obj != null) else if (pm != JDOHelper.getPersistenceManager(value)) throw new JDOUserException(LOCALISER.msg("RDBMS.SCO.Map.WriteValueInvalidWithDifferentPM"),JDOHelper.getObjectId(value));
if ( ( JDOHelper.getObjectId( role ) != null ) && !JDOHelper.isDetached( role ) )
ZooJdoProperties props = new ZooJdoProperties(TestTools.getDbName()); PersistenceManagerFactory pmf = JDOHelper.getPersistenceManagerFactory(props); TestTools.defineSchema(TestSuper.class); TestTools.defineSchema(TestClass.class); assertFalse(JDOHelper.isDeleted(t21)); assertFalse(JDOHelper.isDeleted(t23));
if (!JDOHelper.isPersistent(pc) && !JDOHelper.isDetached(pc)) thePC = getObjectById(JDOHelper.getObjectId(thePC), false);
/** * Utility to validate a key is ok for reading. * @param sm State Manager for the map. * @param key The key to check. * @return Whether it is validated. **/ protected boolean validateKeyForReading(StateManager sm, Object key) { validateKeyType(sm.getPersistenceManager().getClassLoaderResolver(), key); if (!keysAreEmbedded && !keysAreSerialised) { PersistenceManager pm = sm.getPersistenceManager(); if (key!=null && (!JDOHelper.isPersistent(key) || pm != JDOHelper.getPersistenceManager(key)) && !JDOHelper.isDetached(key)) { return false; } } return true; }
private void checkSerialization(TestClassSer tc1, ObjectState state) { TestClassSer x0 = clone(tc1); System.out.println(x0.toString()); JDOHelper.getObjectId(x0); assertEquals(state, JDOHelper.getObjectState(x0)); assertEquals(JDOHelper.getVersion(tc1), JDOHelper.getVersion(x0)); assertEquals(tc1.jdoZooGetTimestamp(), x0.jdoZooGetTimestamp()); assertEquals(tc1.jdoZooGetOid(), x0.jdoZooGetOid()); //TODO // assertEquals(JDOHelper.getObjectId(tc1), JDOHelper.getObjectId(x0)); assertEquals(5, x0.getMyInt()); }
pm.currentTransaction().commit(); assertFalse(JDOHelper.isNew(tc)); assertFalse(JDOHelper.isDirty(tc)); assertTrue(JDOHelper.isPersistent(tc)); assertFalse(JDOHelper.isNew(tc2)); assertFalse(JDOHelper.isDirty(tc2)); assertTrue(JDOHelper.isPersistent(tc2)); JDOHelper.makeDirty(tc2, "_long"); assertTrue(JDOHelper.isDirty(tc2)); pm.currentTransaction().commit(); assertFalse(JDOHelper.isDirty(tc2)); assertFalse(JDOHelper.isDeleted(tc2)); pm.deletePersistent(tc2); assertTrue(JDOHelper.isDeleted(tc2)); pm.currentTransaction().commit();
assertDetachable(pc); if (JDOHelper.isDetached(pc)) if (!JDOHelper.isPersistent(pc))
assertTrue(JDOHelper.isNew(tc)); assertTrue(JDOHelper.isDirty(tc)); //JDO 2.2 12.6.7 makePersistent() assertTrue(JDOHelper.isPersistent(tc)); //JDO 2.2 12.6.7 makePersistent()
assertNull(JDOHelper.getObjectId(tc)); tc.setInt(555); assertEquals(555, tc.getInt()); assertFalse(JDOHelper.isPersistent(tc));
/** * Accessor for whether the passed object is persistent. * @param obj The object * @return Whether it is persistent */ public boolean isPersistent(Object obj) { // Relay through to JDOHelper - TODO Change this when we JPOX-JPA doesnt depend on JDO return JDOHelper.isPersistent(obj); }
/** * Accessor for whether the passed object is dirty. * @param obj The object * @return Whether it is dirty */ public boolean isDirty(Object obj) { // Relay through to JDOHelper - TODO Change this when we JPOX-JPA doesnt depend on JDO return JDOHelper.isDirty(obj); }
assertTrue(JDOHelper.isDeleted(t1)); assertTrue(JDOHelper.isPersistent(t1)); assertTrue(JDOHelper.isDeleted(t2)); assertTrue(JDOHelper.isPersistent(t2));
@Test public void testSingleEvict() { PersistenceManager pm = TestTools.openPM(); pm.currentTransaction().begin(); TestClass tc = new TestClass(); tc.setInt(55); pm.makePersistent(tc); pm.currentTransaction().commit(); pm.currentTransaction().begin(); pm.evict(tc); assertEquals(ObjectState.HOLLOW_PERSISTENT_NONTRANSACTIONAL, JDOHelper.getObjectState(tc)); assertEquals(55, tc.getInt()); tc.setInt(555); assertEquals(555, tc.getInt()); assertTrue(JDOHelper.isPersistent(tc)); //does commit work? pm.deletePersistent(tc); pm.currentTransaction().commit(); pm.close(); }