diff --git a/src/main/java/com/avaje/ebean/event/AbstractBeanPersistListener.java b/src/main/java/com/avaje/ebean/event/AbstractBeanPersistListener.java
index 20af32c96..6f2c885c5 100644
--- a/src/main/java/com/avaje/ebean/event/AbstractBeanPersistListener.java
+++ b/src/main/java/com/avaje/ebean/event/AbstractBeanPersistListener.java
@@ -13,8 +13,7 @@ import java.util.Set;
public abstract class AbstractBeanPersistListener implements BeanPersistListener {
/**
- * Notified that a bean has been inserted locally. Return true if you want the
- * cluster to be notified of the event.
+ * Notified that a bean has been inserted.
*
* @param bean The bean that was inserted.
*/
@@ -23,8 +22,7 @@ public abstract class AbstractBeanPersistListener implements BeanPersistListener
}
/**
- * Notified that a bean has been updated locally. Return true if you want the
- * cluster to be notified of the event.
+ * Notified that a bean has been updated.
*
* @param bean The bean that was updated.
* @param updatedProperties The properties that were modified by this update.
@@ -34,8 +32,7 @@ public abstract class AbstractBeanPersistListener implements BeanPersistListener
}
/**
- * Notified that a bean has been deleted locally. Return true if you want the
- * cluster to be notified of the event.
+ * Notified that a bean has been deleted.
*
* @param bean The bean that was deleted.
*/
@@ -43,4 +40,12 @@ public abstract class AbstractBeanPersistListener implements BeanPersistListener
public void deleted(Object bean) {
}
+ /**
+ * Notified that a bean has been soft deleted.
+ *
+ * @param bean The bean that was deleted.
+ */
+ @Override
+ public void softDeleted(Object bean) {
+ }
}
diff --git a/src/main/java/com/avaje/ebean/event/BeanPersistAdapter.java b/src/main/java/com/avaje/ebean/event/BeanPersistAdapter.java
index 7cdab42ba..5d0412a49 100644
--- a/src/main/java/com/avaje/ebean/event/BeanPersistAdapter.java
+++ b/src/main/java/com/avaje/ebean/event/BeanPersistAdapter.java
@@ -46,6 +46,13 @@ public abstract class BeanPersistAdapter implements BeanPersistController {
return true;
}
+ /**
+ * Returns true indicating normal processing should continue.
+ */
+ public boolean preSoftDelete(BeanPersistRequest request) {
+ return true;
+ }
+
/**
* Does nothing by default.
*/
@@ -64,4 +71,10 @@ public abstract class BeanPersistAdapter implements BeanPersistController {
public void postUpdate(BeanPersistRequest request) {
}
+ /**
+ * Does nothing by default.
+ */
+ public void postSoftDelete(BeanPersistRequest request) {
+ }
+
}
diff --git a/src/main/java/com/avaje/ebean/event/BeanPersistController.java b/src/main/java/com/avaje/ebean/event/BeanPersistController.java
index 84a53a79a..6896350d0 100644
--- a/src/main/java/com/avaje/ebean/event/BeanPersistController.java
+++ b/src/main/java/com/avaje/ebean/event/BeanPersistController.java
@@ -89,6 +89,12 @@ public interface BeanPersistController {
*/
boolean preDelete(BeanPersistRequest request);
+ /**
+ * Prior to a soft delete perform some action. Return true if you want the
+ * default functionality to continue.
+ */
+ boolean preSoftDelete(BeanPersistRequest request);
+
/**
* Called after the insert was performed.
*/
@@ -104,4 +110,8 @@ public interface BeanPersistController {
*/
void postDelete(BeanPersistRequest request);
+ /**
+ * Called after the soft delete was performed.
+ */
+ void postSoftDelete(BeanPersistRequest request);
}
diff --git a/src/main/java/com/avaje/ebean/event/BeanPersistListener.java b/src/main/java/com/avaje/ebean/event/BeanPersistListener.java
index 45389c83f..ad4c0eb66 100644
--- a/src/main/java/com/avaje/ebean/event/BeanPersistListener.java
+++ b/src/main/java/com/avaje/ebean/event/BeanPersistListener.java
@@ -67,4 +67,12 @@ public interface BeanPersistListener {
*/
void deleted(Object bean);
+ /**
+ * Notified that a bean has been soft deleted.
+ *
+ * @param bean
+ * The bean that was soft deleted.
+ */
+ void softDeleted(Object bean);
+
}
diff --git a/src/main/java/com/avaje/ebeaninternal/api/ManyWhereJoins.java b/src/main/java/com/avaje/ebeaninternal/api/ManyWhereJoins.java
index c98837a6d..1a1519b4c 100644
--- a/src/main/java/com/avaje/ebeaninternal/api/ManyWhereJoins.java
+++ b/src/main/java/com/avaje/ebeaninternal/api/ManyWhereJoins.java
@@ -155,4 +155,11 @@ public class ManyWhereJoins implements Serializable {
aggregation = true;
}
+ /**
+ * Ensure we have the join required to support the aggregation properties.
+ */
+ public void addAggregationJoin(String property) {
+ this.aggregation = true;
+ joins.put(property, new PropertyJoin(property, SqlJoinType.INNER));
+ }
}
diff --git a/src/main/java/com/avaje/ebeaninternal/server/autotune/service/ProfileOriginQuery.java b/src/main/java/com/avaje/ebeaninternal/server/autotune/service/ProfileOriginQuery.java
index 4c1c2044e..b0a938393 100644
--- a/src/main/java/com/avaje/ebeaninternal/server/autotune/service/ProfileOriginQuery.java
+++ b/src/main/java/com/avaje/ebeaninternal/server/autotune/service/ProfileOriginQuery.java
@@ -1,9 +1,9 @@
package com.avaje.ebeaninternal.server.autotune.service;
import com.avaje.ebeaninternal.server.autotune.AutoTuneCollection;
-import com.avaje.ebeaninternal.server.util.LongAdder;
import java.io.Serializable;
+import java.util.concurrent.atomic.LongAdder;
/**
* Used to accumulate query execution statistics for paths relative to the origin query.
diff --git a/src/main/java/com/avaje/ebeaninternal/server/cache/DefaultServerCache.java b/src/main/java/com/avaje/ebeaninternal/server/cache/DefaultServerCache.java
index f6444b840..8a5dc8a32 100644
--- a/src/main/java/com/avaje/ebeaninternal/server/cache/DefaultServerCache.java
+++ b/src/main/java/com/avaje/ebeaninternal/server/cache/DefaultServerCache.java
@@ -4,7 +4,7 @@ import com.avaje.ebean.BackgroundExecutor;
import com.avaje.ebean.cache.ServerCache;
import com.avaje.ebean.cache.ServerCacheOptions;
import com.avaje.ebean.cache.ServerCacheStatistics;
-import com.avaje.ebeaninternal.server.util.LongAdder;
+
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -16,6 +16,7 @@ import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.LongAdder;
/**
* The default cache implementation.
@@ -38,7 +39,6 @@ public class DefaultServerCache implements ServerCache {
*/
protected final Map
+ * Return true if a Sql distinct is required. + *
+ */ + public boolean requireSqlDistinct(ManyWhereJoins manyWhereJoins) { + String joinProperty = aggregationJoin(); + if (joinProperty != null) { + aggregation = true; + manyWhereJoins.addAggregationJoin(joinProperty); + return false; + } else{ + return manyWhereJoins.requireSqlDistinct(); + } + } + + /** + * Return true if this contains an aggregation property. + */ + public boolean isAggregation() { + return aggregation; + } + + /** + * Return the property to join for aggregation. + */ + private String aggregationJoin() { + if (!allProperties) { + for (BeanProperty beanProperty : propsList) { + if (beanProperty.isAggregation()) { + return beanProperty.getElPrefix(); + } + } + } + return null; + } } \ No newline at end of file diff --git a/src/main/java/com/avaje/ebeaninternal/server/querydefn/DefaultOrmQuery.java b/src/main/java/com/avaje/ebeaninternal/server/querydefn/DefaultOrmQuery.java index d1237712d..8ffb97800 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/querydefn/DefaultOrmQuery.java +++ b/src/main/java/com/avaje/ebeaninternal/server/querydefn/DefaultOrmQuery.java @@ -373,9 +373,6 @@ public class DefaultOrmQueryThis class is usually preferable to {@link AtomicLong} when - * multiple threads update a common sum that is used for purposes such - * as collecting statistics, not for fine-grained synchronization - * control. Under low update contention, the two classes have similar - * characteristics. But under high contention, expected throughput of - * this class is significantly higher, at the expense of higher space - * consumption. - * - *
This class extends {@link Number}, but does not define - * methods such as {@code equals}, {@code hashCode} and {@code - * compareTo} because instances are expected to be mutated, and so are - * not useful as collection keys. - * - *
jsr166e note: This class is targeted to be placed in - * java.util.concurrent.atomic. - * - * @since 1.8 - * @author Doug Lea - */ -public class LongAdder extends Striped64 implements Serializable { - private static final long serialVersionUID = 7249069246863182397L; - - /** - * Version of plus for use in retryUpdate - */ - final long fn(long v, long x) { return v + x; } - - /** - * Creates a new adder with initial sum of zero. - */ - public LongAdder() { - } - - /** - * Adds the given value. - * - * @param x the value to add - */ - public void add(long x) { - Cell[] as; long b, v; HashCode hc; Cell a; int n; - if ((as = cells) != null || !casBase(b = base, b + x)) { - boolean uncontended = true; - int h = (hc = threadHashCode.get()).code; - if (as == null || (n = as.length) < 1 || - (a = as[(n - 1) & h]) == null || - !(uncontended = a.cas(v = a.value, v + x))) - retryUpdate(x, hc, uncontended); - } - } - - /** - * Equivalent to {@code add(1)}. - */ - public void increment() { - add(1L); - } - - /** - * Equivalent to {@code add(-1)}. - */ - public void decrement() { - add(-1L); - } - - /** - * Returns the current sum. The returned value is NOT an - * atomic snapshot; invocation in the absence of concurrent - * updates returns an accurate result, but concurrent updates that - * occur while the sum is being calculated might not be - * incorporated. - * - * @return the sum - */ - public long sum() { - long sum = base; - Cell[] as = cells; - if (as != null) { - int n = as.length; - for (int i = 0; i < n; ++i) { - Cell a = as[i]; - if (a != null) - sum += a.value; - } - } - return sum; - } - - /** - * Resets variables maintaining the sum to zero. This method may - * be a useful alternative to creating a new adder, but is only - * effective if there are no concurrent updates. Because this - * method is intrinsically racy, it should only be used when it is - * known that no threads are concurrently updating. - */ - public void reset() { - internalReset(0L); - } - - /** - * Equivalent in effect to {@link #sum} followed by {@link - * #reset}. This method may apply for example during quiescent - * points between multithreaded computations. If there are - * updates concurrent with this method, the returned value is - * not guaranteed to be the final value occurring before - * the reset. - * - * @return the sum - */ - public long sumThenReset() { - long sum = base; - Cell[] as = cells; - base = 0L; - if (as != null) { - int n = as.length; - for (int i = 0; i < n; ++i) { - Cell a = as[i]; - if (a != null) { - sum += a.value; - a.value = 0L; - } - } - } - return sum; - } - - /** - * Returns the String representation of the {@link #sum}. - * @return the String representation of the {@link #sum} - */ - public String toString() { - return Long.toString(sum()); - } - - /** - * Equivalent to {@link #sum}. - * - * @return the sum - */ - public long longValue() { - return sum(); - } - - /** - * Returns the {@link #sum} as an {@code int} after a narrowing - * primitive conversion. - */ - public int intValue() { - return (int)sum(); - } - - /** - * Returns the {@link #sum} as a {@code float} - * after a widening primitive conversion. - */ - public float floatValue() { - return (float)sum(); - } - - /** - * Returns the {@link #sum} as a {@code double} after a widening - * primitive conversion. - */ - public double doubleValue() { - return (double)sum(); - } - - private void writeObject(java.io.ObjectOutputStream s) - throws java.io.IOException { - s.defaultWriteObject(); - s.writeLong(sum()); - } - - private void readObject(java.io.ObjectInputStream s) - throws java.io.IOException, ClassNotFoundException { - s.defaultReadObject(); - busy = 0; - cells = null; - base = s.readLong(); - } - -} \ No newline at end of file diff --git a/src/main/java/com/avaje/ebeaninternal/server/util/LongMaxUpdater.java b/src/main/java/com/avaje/ebeaninternal/server/util/LongMaxUpdater.java deleted file mode 100644 index b702ff262..000000000 --- a/src/main/java/com/avaje/ebeaninternal/server/util/LongMaxUpdater.java +++ /dev/null @@ -1,184 +0,0 @@ -package com.avaje.ebeaninternal.server.util; - -/* - * Written by Doug Lea with assistance from members of JCP JSR-166 - * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/publicdomain/zero/1.0/ - */ - -import java.io.Serializable; - -/** - * One or more variables that together maintain a running {@code long} - * maximum with initial value {@code Long.MIN_VALUE}. When updates - * (method {@link #update}) are contended across threads, the set of - * variables may grow dynamically to reduce contention. Method {@link - * #max} (or, equivalently, {@link #longValue}) returns the current - * maximum across the variables maintaining updates. - * - *
This class extends {@link Number}, but does not define - * methods such as {@code equals}, {@code hashCode} and {@code - * compareTo} because instances are expected to be mutated, and so are - * not useful as collection keys. - * - *
jsr166e note: This class is targeted to be placed in
- * java.util.concurrent.atomic.
- *
- * @since 1.8
- * @author Doug Lea
- */
-public class LongMaxUpdater extends Striped64 implements Serializable {
- private static final long serialVersionUID = 7249069246863182397L;
-
- /**
- * Version of max for use in retryUpdate
- */
- final long fn(long v, long x) { return v > x ? v : x; }
-
- /**
- * Creates a new instance with initial maximum of {@code
- * Long.MIN_VALUE}.
- */
- public LongMaxUpdater() {
- base = Long.MIN_VALUE;
- }
-
- /**
- * Updates the maximum to be at least the given value.
- *
- * @param x the value to update
- */
- public void update(long x) {
- Cell[] as; long b, v; HashCode hc; Cell a; int n;
- if ((as = cells) != null ||
- (b = base) < x && !casBase(b, x)) {
- boolean uncontended = true;
- int h = (hc = threadHashCode.get()).code;
- if (as == null || (n = as.length) < 1 ||
- (a = as[(n - 1) & h]) == null ||
- ((v = a.value) < x && !(uncontended = a.cas(v, x))))
- retryUpdate(x, hc, uncontended);
- }
- }
-
- /**
- * Returns the current maximum. The returned value is
- * NOT an atomic snapshot; invocation in the absence of
- * concurrent updates returns an accurate result, but concurrent
- * updates that occur while the value is being calculated might
- * not be incorporated.
- *
- * @return the maximum
- */
- public long max() {
- Cell[] as = cells;
- long max = base;
- if (as != null) {
- int n = as.length;
- long v;
- for (int i = 0; i < n; ++i) {
- Cell a = as[i];
- if (a != null && (v = a.value) > max)
- max = v;
- }
- }
- return max;
- }
-
- /**
- * Resets variables maintaining updates to {@code Long.MIN_VALUE}.
- * This method may be a useful alternative to creating a new
- * updater, but is only effective if there are no concurrent
- * updates. Because this method is intrinsically racy, it should
- * only be used when it is known that no threads are concurrently
- * updating.
- */
- public void reset() {
- internalReset(Long.MIN_VALUE);
- }
-
- /**
- * Equivalent in effect to {@link #max} followed by {@link
- * #reset}. This method may apply for example during quiescent
- * points between multithreaded computations. If there are
- * updates concurrent with this method, the returned value is
- * not guaranteed to be the final value occurring before
- * the reset.
- *
- * @return the maximum
- */
- public long maxThenReset() {
- Cell[] as = cells;
- long max = base;
- base = Long.MIN_VALUE;
- if (as != null) {
- int n = as.length;
- for (int i = 0; i < n; ++i) {
- Cell a = as[i];
- if (a != null) {
- long v = a.value;
- a.value = Long.MIN_VALUE;
- if (v > max)
- max = v;
- }
- }
- }
- return max;
- }
-
- /**
- * Returns the String representation of the {@link #max}.
- * @return the String representation of the {@link #max}
- */
- public String toString() {
- return Long.toString(max());
- }
-
- /**
- * Equivalent to {@link #max}.
- *
- * @return the maximum
- */
- public long longValue() {
- return max();
- }
-
- /**
- * Returns the {@link #max} as an {@code int} after a narrowing
- * primitive conversion.
- */
- public int intValue() {
- return (int)max();
- }
-
- /**
- * Returns the {@link #max} as a {@code float}
- * after a widening primitive conversion.
- */
- public float floatValue() {
- return (float)max();
- }
-
- /**
- * Returns the {@link #max} as a {@code double} after a widening
- * primitive conversion.
- */
- public double doubleValue() {
- return (double)max();
- }
-
- private void writeObject(java.io.ObjectOutputStream s)
- throws java.io.IOException {
- s.defaultWriteObject();
- s.writeLong(max());
- }
-
- private void readObject(java.io.ObjectInputStream s)
- throws java.io.IOException, ClassNotFoundException {
- s.defaultReadObject();
- busy = 0;
- cells = null;
- base = s.readLong();
- }
-
-}
diff --git a/src/main/java/com/avaje/ebeaninternal/server/util/Stripped64.java b/src/main/java/com/avaje/ebeaninternal/server/util/Stripped64.java
deleted file mode 100644
index eed973fb6..000000000
--- a/src/main/java/com/avaje/ebeaninternal/server/util/Stripped64.java
+++ /dev/null
@@ -1,342 +0,0 @@
-package com.avaje.ebeaninternal.server.util;
-
-/*
- * Written by Doug Lea with assistance from members of JCP JSR-166
- * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/publicdomain/zero/1.0/
- */
-
-import java.util.Random;
-
-/**
- * A package-local class holding common representation and mechanics
- * for classes supporting dynamic striping on 64bit values. The class
- * extends Number so that concrete subclasses must publicly do so.
- */
-abstract class Striped64 extends Number {
- /*
- * This class maintains a lazily-initialized table of atomically
- * updated variables, plus an extra "base" field. The table size
- * is a power of two. Indexing uses masked per-thread hash codes.
- * Nearly all declarations in this class are package-private,
- * accessed directly by subclasses.
- *
- * Table entries are of class Cell; a variant of AtomicLong padded
- * to reduce cache contention on most processors. Padding is
- * overkill for most Atomics because they are usually irregularly
- * scattered in memory and thus don't interfere much with each
- * other. But Atomic objects residing in arrays will tend to be
- * placed adjacent to each other, and so will most often share
- * cache lines (with a huge negative performance impact) without
- * this precaution.
- *
- * In part because Cells are relatively large, we avoid creating
- * them until they are needed. When there is no contention, all
- * updates are made to the base field. Upon first contention (a
- * failed CAS on base update), the table is initialized to size 2.
- * The table size is doubled upon further contention until
- * reaching the nearest power of two greater than or equal to the
- * number of CPUS. Table slots remain empty (null) until they are
- * needed.
- *
- * A single spinlock ("busy") is used for initializing and
- * resizing the table, as well as populating slots with new Cells.
- * There is no need for a blocking lock; when the lock is not
- * available, threads try other slots (or the base). During these
- * retries, there is increased contention and reduced locality,
- * which is still better than alternatives.
- *
- * Per-thread hash codes are initialized to random values.
- * Contention and/or table collisions are indicated by failed
- * CASes when performing an update operation (see method
- * retryUpdate). Upon a collision, if the table size is less than
- * the capacity, it is doubled in size unless some other thread
- * holds the lock. If a hashed slot is empty, and lock is
- * available, a new Cell is created. Otherwise, if the slot
- * exists, a CAS is tried. Retries proceed by "double hashing",
- * using a secondary hash (Marsaglia XorShift) to try to find a
- * free slot.
- *
- * The table size is capped because, when there are more threads
- * than CPUs, supposing that each thread were bound to a CPU,
- * there would exist a perfect hash function mapping threads to
- * slots that eliminates collisions. When we reach capacity, we
- * search for this mapping by randomly varying the hash codes of
- * colliding threads. Because search is random, and collisions
- * only become known via CAS failures, convergence can be slow,
- * and because threads are typically not bound to CPUS forever,
- * may not occur at all. However, despite these limitations,
- * observed contention rates are typically low in these cases.
- *
- * It is possible for a Cell to become unused when threads that
- * once hashed to it terminate, as well as in the case where
- * doubling the table causes no thread to hash to it under
- * expanded mask. We do not try to detect or remove such cells,
- * under the assumption that for long-running instances, observed
- * contention levels will recur, so the cells will eventually be
- * needed again; and for short-lived ones, it does not matter.
- */
-
- /**
- * Padded variant of AtomicLong supporting only raw accesses plus CAS.
- * The value field is placed between pads, hoping that the JVM doesn't
- * reorder them.
- *
- * JVM intrinsics note: It would be possible to use a release-only
- * form of CAS here, if it were provided.
- */
- static final class Cell {
- volatile long p0, p1, p2, p3, p4, p5, p6;
- volatile long value;
- volatile long q0, q1, q2, q3, q4, q5, q6;
- Cell(long x) { value = x; }
-
- final boolean cas(long cmp, long val) {
- return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
- }
-
- // Unsafe mechanics
- private static final sun.misc.Unsafe UNSAFE;
- private static final long valueOffset;
- static {
- try {
- UNSAFE = getUnsafe();
- Class ak = Cell.class;
- valueOffset = UNSAFE.objectFieldOffset
- (ak.getDeclaredField("value"));
- } catch (Exception e) {
- throw new Error(e);
- }
- }
-
- }
-
- /**
- * Holder for the thread-local hash code. The code is initially
- * random, but may be set to a different value upon collisions.
- */
- static final class HashCode {
- static final Random rng = new Random();
- int code;
- HashCode() {
- int h = rng.nextInt(); // Avoid zero to allow xorShift rehash
- code = (h == 0) ? 1 : h;
- }
- }
-
- /**
- * The corresponding ThreadLocal class
- */
- static final class ThreadHashCode extends ThreadLocal