Added Query.distinct(). However, useless without project().

stickfigure · stickfigure · commit 042f00249a28 · 2013-01-22T20:13:03.000-05:00
diff --git a/src/main/java/com/googlecode/objectify/cmd/SimpleQuery.java b/src/main/java/com/googlecode/objectify/cmd/SimpleQuery.java
@@ -6,101 +6,106 @@
 
 /**
  * A restricted set of query operations that apply to both kindless queries and typed queries.
- * 
+ *
  * @author Jeff Schnitzer <jeff@infohazard.org>
  */
 public interface SimpleQuery<T> extends QueryExecute<T>
 {
 	/**
 	 * <p>Create a filter on the key of an entity. Examples:</p>
-	 * 
+	 *
 	 * <ul>
 	 * <li>{@code filterKey(">=", key)} (standard inequalities)</li>
 	 * <li>{@code filterKey("=", key)} (wouldn't you rather do a load-by-key?)</li>
 	 * <li>{@code filterKey("", key)} (if no operator, = is assumed)</li>
 	 * <li>{@code filterKey("!=", key)}</li>
 	 * <li>{@code filterKey("in", keyList)} (wouldn't you rather do a batch load-by-key?)</li>
 	 * </ul>
-	 * 
+	 *
 	 * <p>The key parameter can be anything key-ish; a Key<?>, a native datastore key, a Ref, a pojo entity, etc.</p>
-	 * 
-	 * <p>See the Google documentation for 
+	 *
+	 * <p>See the Google documentation for
 	 * <a href="http://code.google.com/appengine/docs/java/datastore/queries.html#Introduction_to_Indexes">indexes</a>
 	 * for an explanation of what you can and cannot filter for.</p>
 	 */
 	public SimpleQuery<T> filterKey(String condition, Object value);
-	
+
 	/**
 	 * An alias for {@code filterKey("=", value)}
 	 */
 	public SimpleQuery<T> filterKey(Object value);
-	
+
 	/**
 	 * Restricts result set only to objects which have the given ancestor
 	 * somewhere in the chain.  Doesn't need to be the immediate parent.
-	 * 
+	 *
 	 * @param keyOrEntity can be a Key, a Key<T>, or an Objectify entity object.
 	 */
 	public SimpleQuery<T> ancestor(Object keyOrEntity);
-	
+
 	/**
 	 * Limit the fetched result set to a certain number of values.
-	 * 
+	 *
 	 * @param value must be >= 0.  A value of 0 indicates no limit.
 	 */
 	public SimpleQuery<T> limit(int value);
-	
+
 	/**
 	 * Starts the query results at a particular zero-based offset.  This can be extraordinarily
 	 * expensive because each skipped entity is billed as a "minor datastore operation".  If you
 	 * can, you probably want to use cursors instead.
-	 * 
+	 *
 	 * @param value must be >= 0
 	 */
 	public SimpleQuery<T> offset(int value);
-	
+
 	/**
 	 * Starts query results at the specified Cursor.  You can obtain a Cursor from
 	 * a QueryResultIterator by calling the getCursor() method.
-	 * 
+	 *
 	 * Note that limit() and offset() are NOT encoded within a cursor; they operate
 	 * on the results of the query after a cursor is established.
 	 */
 	public SimpleQuery<T> startAt(Cursor value);
-	
+
 	/**
 	 * Ends query results at the specified Cursor.  You can obtain a Cursor from
 	 * a QueryResultIterator by calling the getCursor() method.
-	 * 
+	 *
 	 * Note that limit() and offset() are NOT encoded within a cursor; they operate
 	 * on the results of the query after a cursor is established.
 	 */
 	public SimpleQuery<T> endAt(Cursor value);
-	
+
 	/**
 	 * Sets the internal chunking and prefetching strategy within the low-level API.  Affects
 	 * performance only; the result set will be the same.
-	 *  
+	 *
 	 * @param value must be >= 0
 	 */
 	public SimpleQuery<T> chunk(int value);
-	
+
 	/**
 	 * <p>Sets the internal chunking and prefetching strategy within the low-level API to attempt to get all
 	 * results at once.  Affects performance only; the result set will be the same.</p>
-	 * 
+	 *
 	 * <p>Same as chunk(Integer.MAX_VALUE).</p>
 	 */
 	public SimpleQuery<T> chunkAll();
-	
+
+	/**
+	 * Determines whether this is a SELECT DISTINCT query.
+	 */
+	public SimpleQuery<T> distinct(boolean value);
+
 	/**
 	 * <p>This method forces Objectify to (or not to) hybridize the query into a keys-only fetch plus batch get.</p>
-	 * 
+	 *
 	 * <p>If Objectify knows you are fetching an entity type that can be cached, it automatically converts
 	 * queries into a "hybrid" of keys-only query followed by a batch fetch of the keys.  This is cheaper (keys-only
 	 * results are 1/7th the price of a full fetch) and, if the cache hits, significantly faster.  However,
 	 * there are some circumstances in which you may wish to force behavior one way or another:</p>
-	 * 
+	 *
 	 * <ul>
 	 * <li>Issuing a kindless query (which Objectify will not auto-hybridize) when you know a significant portion
 	 * of the result set is cacheable.</li>
@@ -110,50 +115,50 @@ public interface SimpleQuery<T> extends QueryExecute<T>
 	 * <li>Hybrid queries have a slightly different consistency model than normal queries.  You may wish to
 	 * force hybridization off to ensure a weakly consistent query (see below).</li>
 	 * </ul>
-	 * 
+	 *
 	 * <p>For the most part, hybridization only affects the performance and cost of queries.  However, it is possible
 	 * for hybridization to alter the content of the result set.  In the HRD, queries
 	 * always have EVENTUAL consistency but get operations may have either STRONG or EVENTUAL consistency depending
 	 * on the read policy (see {@code Objectify.consistency()}.  The keys-only query results will always be EVENTUAL and may
 	 * return data that has been deleted, but Objectify will exclude these results when the more-current batch get fails to return
 	 * data.  So the count of the returned data may actually be less than the limit(), even if there are plenty of
 	 * actual results.  {@code hybrid(false)} will prevent this behavior.</p>
-	 * 
+	 *
 	 * <p>Note that in hybrid queries, the chunk size defines the batch size.</p>
 	 */
 	public SimpleQuery<T> hybrid(boolean force);
-	
+
 	/**
 	 * Switches to a keys-only query.  Keys-only responses are billed as "minor datastore operations"
 	 * which are significantly cheaper (~7X) than fetching whole entities.
 	 */
 	public QueryKeys<T> keys();
-	
+
 	/**
 	 * <p>Count the total number of values in the result.  <em>limit</em> and <em>offset</em> are obeyed.
 	 * This is somewhat faster than fetching, but the time still grows with the number of results.
 	 * The datastore actually walks through the result set and counts for you.</p>
-	 * 
+	 *
 	 * <p>Immediately executes the query; there is no async version of this method.</p>
-	 * 
+	 *
 	 * <p>WARNING:  Each counted entity is billed as a "datastore minor operation".  Counting large numbers
 	 * of entities can quickly create massive bills.</p>
 	 */
 	public int count();
 
 	/**
 	 * Gets the first entity in the result set.  Obeys the offset value.
-	 * 
+	 *
 	 * @return an asynchronous Ref containing the first result.  The Ref will hold null if the result set is empty.
 	 */
 	public Ref<T> first();
-	
+
 	/**
 	 * <p>Generates a string that consistently and uniquely specifies this query.  There
 	 * is no way to convert this string back into a query and there is no guarantee that
 	 * the string will be consistent across versions of Objectify.</p>
-	 * 
-	 * <p>In particular, this value is useful as a key for a simple memcache query cache.</p> 
+	 *
+	 * <p>In particular, this value is useful as a key for a simple memcache query cache.</p>
 	 */
 	public String toString();
 }
diff --git a/src/main/java/com/googlecode/objectify/impl/cmd/QueryImpl.java b/src/main/java/com/googlecode/objectify/impl/cmd/QueryImpl.java
@@ -271,6 +271,11 @@ void setKeysOnly() {
 		this.actual.setKeysOnly();
 	}
 
+	/** Modifies the instance */
+	void setDistinct(boolean value) {
+		this.actual.setDistinct(value);
+	}
+
 	/* (non-Javadoc)
 	 * @see java.lang.Object#toString()
 	 */
@@ -348,6 +353,9 @@ public int compare(SortPredicate o1, SortPredicate o2)
 		if (this.endAt != null)
 			bld.append(",endAt=").append(this.endAt.toWebSafeString());
 
+		if (this.actual.getDistinct())
+			bld.append(",distinct=true");
+
 		bld.append('}');
 
 		return bld.toString();
diff --git a/src/main/java/com/googlecode/objectify/impl/cmd/SimpleQueryImpl.java b/src/main/java/com/googlecode/objectify/impl/cmd/SimpleQueryImpl.java
@@ -9,21 +9,21 @@
 /**
  * Base for command classes that include methods for defining a query (filter, order, limit, etc).
  * Does not include the methods for executing a query.
- * 
+ *
  * @author Jeff Schnitzer <jeff@infohazard.org>
  */
 abstract class SimpleQueryImpl<T> implements SimpleQuery<T>
 {
 	/** */
 	protected LoaderImpl loader;
-	
+
 	/**
 	 * There is a special case - if loader is null, use 'this' as the LoaderImpl
 	 */
 	SimpleQueryImpl(LoaderImpl loader) {
 		this.loader = loader == null ? (LoaderImpl)this : loader;
 	}
-	
+
 	/**
 	 * Create an initial query object; for a real FindType this will have a class, otherwise it will be generic.
 	 * For the real QueryImpl itself this is a clone() operation.
@@ -40,7 +40,7 @@ public QueryImpl<T> filterKey(String condition, Object value)
 		q.addFilter(Entity.KEY_RESERVED_PROPERTY + " " + condition, value);
 		return q;
 	}
-	
+
 	/* (non-Javadoc)
 	 * @see com.googlecode.objectify.cmd.SimpleQuery#filterKey(java.lang.Object)
 	 */
@@ -49,7 +49,7 @@ public QueryImpl<T> filterKey(Object value)
 	{
 		return filterKey("=", value);
 	}
-	
+
 	/* (non-Javadoc)
 	 * @see com.googlecode.objectify.cmd.Query#ancestor(java.lang.Object)
 	 */
@@ -115,7 +115,18 @@ public QueryImpl<T> chunk(int value)
 		q.setChunk(value);
 		return q;
 	}
-	
+
+	/* (non-Javadoc)
+	 * @see com.googlecode.objectify.cmd.SimpleQuery#distinct(boolean)
+	 */
+	@Override
+	public QueryImpl<T> distinct(boolean value)
+	{
+		QueryImpl<T> q = createQuery();
+		q.setDistinct(value);
+		return q;
+	}
+
 	/* (non-Javadoc)
 	 * @see com.googlecode.objectify.cmd.SimpleQuery#hybrid(boolean)
 	 */
diff --git a/src/main/java/com/googlecode/objectify/util/cmd/SimpleQueryWrapper.java b/src/main/java/com/googlecode/objectify/util/cmd/SimpleQueryWrapper.java
@@ -11,53 +11,53 @@
 
 /**
  * Simple wrapper/decorator for a SimpleQuery.  Use it like this:
- * {@code class MySimpleQuery<T> extends SimpleQueryWrapper<MyQuery<T>, T>} 
+ * {@code class MySimpleQuery<T> extends SimpleQueryWrapper<MyQuery<T>, T>}
  *
  * @author Jeff Schnitzer <jeff@infohazard.org>
  */
 public class SimpleQueryWrapper<H extends SimpleQueryWrapper<H, T>, T> implements SimpleQuery<T>, Cloneable
 {
 	/** */
 	SimpleQuery<T> base;
-	
+
 	/** */
-	public SimpleQueryWrapper(SimpleQuery<T> base) 
+	public SimpleQueryWrapper(SimpleQuery<T> base)
 	{
 		this.base = base;
 	}
-	
+
 	@Override
 	public H filterKey(String condition, Object value)
 	{
 		H next = this.clone();
 		next.base = base.filterKey(condition, value);
 		return next;
 	}
-	
+
 	@Override
 	public SimpleQuery<T> filterKey(Object value)
 	{
 		H next = this.clone();
 		next.base = base.filterKey(value);
 		return next;
 	}
-	
+
 	@Override
 	public H ancestor(Object keyOrEntity)
 	{
 		H next = this.clone();
 		next.base = base.ancestor(keyOrEntity);
 		return next;
 	}
-	
+
 	@Override
 	public H limit(int value)
 	{
 		H next = this.clone();
 		next.base = base.limit(value);
 		return next;
 	}
-	
+
 	@Override
 	public H offset(int value)
 	{
@@ -127,7 +127,15 @@ public H chunkAll()
 		next.base = base.chunkAll();
 		return next;
 	}
-	
+
+	@Override
+	public H distinct(boolean value)
+	{
+		H next = this.clone();
+		next.base = base.distinct(value);
+		return next;
+	}
+
 	@Override
 	public H hybrid(boolean force)
 	{
@@ -141,7 +149,7 @@ public QueryResultIterator<T> iterator()
 	{
 		return base.iterator();
 	}
-	
+
 	@Override
 	public QueryKeys<T> keys()
 	{

Original file line number	Diff line number	Diff line change
`@@ -11,53 +11,53 @@`
`11`	`11`
`12`	`12`	`/**`
`13`	`13`	`* Simple wrapper/decorator for a SimpleQuery. Use it like this:`
`14`		`- * {@code class MySimpleQuery<T> extends SimpleQueryWrapper<MyQuery<T>, T>}`
	`14`	`+ * {@code class MySimpleQuery<T> extends SimpleQueryWrapper<MyQuery<T>, T>}`
`15`	`15`	`*`
`16`	`16`	`* @author Jeff Schnitzer <jeff@infohazard.org>`
`17`	`17`	`*/`
`18`	`18`	`public class SimpleQueryWrapper<H extends SimpleQueryWrapper<H, T>, T> implements SimpleQuery<T>, Cloneable`
`19`	`19`	`{`
`20`	`20`	`/** */`
`21`	`21`	`SimpleQuery<T> base;`
`22`		`-`
	`22`	`+`
`23`	`23`	`/** */`
`24`		`- public SimpleQueryWrapper(SimpleQuery<T> base)`
	`24`	`+ public SimpleQueryWrapper(SimpleQuery<T> base)`
`25`	`25`	`{`
`26`	`26`	`this.base = base;`
`27`	`27`	`}`
`28`		`-`
	`28`	`+`
`29`	`29`	`@Override`
`30`	`30`	`public H filterKey(String condition, Object value)`
`31`	`31`	`{`
`32`	`32`	`H next = this.clone();`
`33`	`33`	`next.base = base.filterKey(condition, value);`
`34`	`34`	`return next;`
`35`	`35`	`}`
`36`		`-`
	`36`	`+`
`37`	`37`	`@Override`
`38`	`38`	`public SimpleQuery<T> filterKey(Object value)`
`39`	`39`	`{`
`40`	`40`	`H next = this.clone();`
`41`	`41`	`next.base = base.filterKey(value);`
`42`	`42`	`return next;`
`43`	`43`	`}`
`44`		`-`
	`44`	`+`
`45`	`45`	`@Override`
`46`	`46`	`public H ancestor(Object keyOrEntity)`
`47`	`47`	`{`
`48`	`48`	`H next = this.clone();`
`49`	`49`	`next.base = base.ancestor(keyOrEntity);`
`50`	`50`	`return next;`
`51`	`51`	`}`
`52`		`-`
	`52`	`+`
`53`	`53`	`@Override`
`54`	`54`	`public H limit(int value)`
`55`	`55`	`{`
`56`	`56`	`H next = this.clone();`
`57`	`57`	`next.base = base.limit(value);`
`58`	`58`	`return next;`
`59`	`59`	`}`
`60`		`-`
	`60`	`+`
`61`	`61`	`@Override`
`62`	`62`	`public H offset(int value)`
`63`	`63`	`{`
`@@ -127,7 +127,15 @@ public H chunkAll()`
`127`	`127`	`next.base = base.chunkAll();`
`128`	`128`	`return next;`
`129`	`129`	`}`
`130`		`-`
	`130`	`+`
	`131`	`+ @Override`
	`132`	`+ public H distinct(boolean value)`
	`133`	`+ {`
	`134`	`+ H next = this.clone();`
	`135`	`+ next.base = base.distinct(value);`
	`136`	`+ return next;`
	`137`	`+ }`
	`138`	`+`
`131`	`139`	`@Override`
`132`	`140`	`public H hybrid(boolean force)`
`133`	`141`	`{`
`@@ -141,7 +149,7 @@ public QueryResultIterator<T> iterator()`
`141`	`149`	`{`
`142`	`150`	`return base.iterator();`
`143`	`151`	`}`
`144`		`-`
	`152`	`+`
`145`	`153`	`@Override`
`146`	`154`	`public QueryKeys<T> keys()`
`147`	`155`	`{`