diff --git a/src/main/java/com/avaje/ebean/bean/PersistenceContext.java b/src/main/java/com/avaje/ebean/bean/PersistenceContext.java index 01bb2eb25..f97d43419 100644 --- a/src/main/java/com/avaje/ebean/bean/PersistenceContext.java +++ b/src/main/java/com/avaje/ebean/bean/PersistenceContext.java @@ -29,6 +29,13 @@ public interface PersistenceContext { */ public Object get(Class beanType, Object uid); + /** + * Get the bean from the persistence context also checked to see if it had + * been previously deleted (if so then you also can't hit the L2 cache to + * fetch the bean for this particular persistence context). + */ + public WithOption getWithOption(Class beanType, Object uid); + /** * Clear all the references. */ @@ -44,9 +51,60 @@ public interface PersistenceContext { */ public void clear(Class beanType, Object uid); + /** + * Clear the reference as a result of an entity being deleted. + */ + public void deleted(Class beanType, Object id); + /** * Return the number of beans of the given type in the persistence context. */ public int size(Class beanType); + /** + * Wrapper on a bean to also indicate if a bean has been deleted. + *

+ * If a bean has been deleted then for the same persistence context is should + * not be able to be fetched from persistence context or L2 cache. + *

+ */ + public static class WithOption { + + /** + * The bean was previously deleted from this persistence context (can't hit + * L2 cache). + */ + public static WithOption DELETED = new WithOption(true); + + private final boolean deleted; + private final Object bean; + + private WithOption(boolean deleted) { + this.deleted = true; + this.bean = null; + } + + /** + * The bean exists in the persistence context (and not been previously deleted). + */ + public WithOption(Object bean) { + this.deleted = false; + this.bean = bean; + } + + /** + * Return true if the bean was deleted. This means you can't hit the L2 + * cache. + */ + public boolean isDeleted() { + return deleted; + } + + /** + * Return the bean (from the persistence context). + */ + public Object getBean() { + return bean; + } + } } diff --git a/src/main/java/com/avaje/ebeaninternal/server/core/DefaultServer.java b/src/main/java/com/avaje/ebeaninternal/server/core/DefaultServer.java index bdd9d10c1..ab9a46d53 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/core/DefaultServer.java +++ b/src/main/java/com/avaje/ebeaninternal/server/core/DefaultServer.java @@ -50,6 +50,7 @@ import com.avaje.ebean.bean.CallStack; import com.avaje.ebean.bean.EntityBean; import com.avaje.ebean.bean.EntityBeanIntercept; import com.avaje.ebean.bean.PersistenceContext; +import com.avaje.ebean.bean.PersistenceContext.WithOption; import com.avaje.ebean.cache.ServerCacheManager; import com.avaje.ebean.config.EncryptKeyManager; import com.avaje.ebean.config.GlobalProperties; @@ -1136,9 +1137,14 @@ public final class DefaultServer implements SpiEbeanServer { // first look in the persistence context context = t.getPersistenceContext(); if (context != null) { - Object o = context.get(beanDescriptor.getBeanType(), query.getId()); + WithOption o = context.getWithOption(beanDescriptor.getBeanType(), query.getId()); if (o != null) { - return (T) o; + if (o.isDeleted()) { + // Bean was previously deleted in the same transaction / persistence context + return null; + } + // Return the entity bean instance from the persistence context + return (T) o.getBean(); } } } @@ -1148,6 +1154,7 @@ public final class DefaultServer implements SpiEbeanServer { return null; } + // Hit the L2 bean cache Object cachedBean = beanDescriptor.cacheGetBean(query.getId(), query.isReadOnly()); if (cachedBean != null) { if (context == null) { diff --git a/src/main/java/com/avaje/ebeaninternal/server/persist/DefaultPersister.java b/src/main/java/com/avaje/ebeaninternal/server/persist/DefaultPersister.java index 1617d52b5..8e6f44896 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/persist/DefaultPersister.java +++ b/src/main/java/com/avaje/ebeaninternal/server/persist/DefaultPersister.java @@ -19,6 +19,7 @@ import com.avaje.ebean.bean.BeanCollection; import com.avaje.ebean.bean.BeanCollection.ModifyListenMode; import com.avaje.ebean.bean.EntityBean; import com.avaje.ebean.bean.EntityBeanIntercept; +import com.avaje.ebean.bean.PersistenceContext; import com.avaje.ebeaninternal.api.SpiEbeanServer; import com.avaje.ebeaninternal.api.SpiTransaction; import com.avaje.ebeaninternal.api.SpiUpdate; @@ -38,6 +39,7 @@ import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany; import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne; import com.avaje.ebeaninternal.server.deploy.IntersectionRow; import com.avaje.ebeaninternal.server.deploy.ManyType; + import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -538,7 +540,18 @@ public final class DefaultPersister implements Persister { } else { t.getEvent().addDeleteById(descriptor, id); } - return executeSqlUpdate(deleteById, t); + int rows = executeSqlUpdate(deleteById, t); + + // Delete from the persistence context so that it can't be fetched again later + PersistenceContext persistenceContext = ((SpiTransaction)t).getPersistenceContext(); + if (idList != null) { + for (Object idValue : idList) { + persistenceContext.deleted(descriptor.getBeanType(), idValue); + } + } else { + persistenceContext.deleted(descriptor.getBeanType(), id); + } + return rows; } /** diff --git a/src/main/java/com/avaje/ebeaninternal/server/transaction/DefaultPersistenceContext.java b/src/main/java/com/avaje/ebeaninternal/server/transaction/DefaultPersistenceContext.java index 1c8ef9228..d60922443 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/transaction/DefaultPersistenceContext.java +++ b/src/main/java/com/avaje/ebeaninternal/server/transaction/DefaultPersistenceContext.java @@ -1,9 +1,11 @@ package com.avaje.ebeaninternal.server.transaction; import java.util.HashMap; +import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; +import java.util.Set; import com.avaje.ebean.bean.PersistenceContext; import com.avaje.ebeaninternal.api.Monitor; @@ -64,6 +66,12 @@ public final class DefaultPersistenceContext implements PersistenceContext { return getClassContext(beanType).get(id); } } + + public WithOption getWithOption(Class beanType, Object id) { + synchronized (monitor) { + return getClassContext(beanType).getWithOption(id); + } + } /** * Return the number of beans of the given type in the persistence context. @@ -93,11 +101,19 @@ public final class DefaultPersistenceContext implements PersistenceContext { } } + public void deleted(Class beanType, Object id) { + synchronized (monitor) { + ClassContext classMap = typeCache.get(beanType.getName()); + if (classMap != null && id != null) { + classMap.deleted(id); + } + } + } + public void clear(Class beanType, Object id) { synchronized (monitor) { ClassContext classMap = typeCache.get(beanType.getName()); if (classMap != null && id != null) { - //id = getUid(beanType, id); classMap.remove(id); } } @@ -130,16 +146,24 @@ public final class DefaultPersistenceContext implements PersistenceContext { private static class ClassContext { - private final WeakValueMap map = new WeakValueMap(); - + private final WeakValueMap map = new WeakValueMap(); + private Set deleteSet; + + private WithOption getWithOption(Object id){ + if (deleteSet != null && deleteSet.contains(id)) { + return WithOption.DELETED; + } + Object bean = map.get(id); + return (bean == null) ? null : new WithOption(bean); + } + private Object get(Object id){ return map.get(id); } - private Object putIfAbsent(Object id, Object bean){ - - return map.putIfAbsent(id, bean); - } + private Object putIfAbsent(Object id, Object bean){ + return map.putIfAbsent(id, bean); + } private void put(Object id, Object b){ map.put(id, b); @@ -156,6 +180,14 @@ public final class DefaultPersistenceContext implements PersistenceContext { private Object remove(Object id){ return map.remove(id); } + + private void deleted(Object id){ + if (deleteSet == null) { + deleteSet = new HashSet(); + } + deleteSet.add(id); + map.remove(id); + } } } diff --git a/src/test/java/com/avaje/tests/delete/TestDeleteByIdWithPersistenceContext.java b/src/test/java/com/avaje/tests/delete/TestDeleteByIdWithPersistenceContext.java new file mode 100644 index 000000000..97d3e6b48 --- /dev/null +++ b/src/test/java/com/avaje/tests/delete/TestDeleteByIdWithPersistenceContext.java @@ -0,0 +1,52 @@ +package com.avaje.tests.delete; + +import java.util.Arrays; + +import org.junit.Assert; +import org.junit.Test; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.EbeanServer; +import com.avaje.tests.model.basic.Product; +import com.avaje.tests.model.basic.ResetBasicData; + +public class TestDeleteByIdWithPersistenceContext extends BaseTestCase { + + @Test + public void test() { + + ResetBasicData.reset(); + + EbeanServer server = Ebean.getServer(null); + Product prod1 = createProduct(100,"apples"); + server.save(prod1); + Product prod2 = createProduct(101, "bananas"); + server.save(prod2); + + server.beginTransaction(); + // effectively load these into the persistence context + server.find(Product.class, prod1.getId()); + server.find(Product.class, prod2.getId()); + + server.delete(Product.class, Arrays.asList(prod1.getId(), prod2.getId())); + + // are these found in the persistence context? + Product shadow1 = server.find(Product.class, prod1.getId()); + Product shadow2 = server.find(Product.class, prod2.getId()); + + Assert.assertNull(shadow1); + Assert.assertNull(shadow2); + + server.endTransaction(); + + } + + private Product createProduct(Integer id, String name) { + Product prod = new Product(); + prod.setId(id); + prod.setName(name); + return prod; + } + +}