com.mysema.query.group

Class GroupBy

java.lang.Object

com.mysema.query.group.GroupBy

public final class GroupBy
extends Object

Groups results by the first expression.

Author:

sasa, tiwe

Method Summary

Methods

Modifier and Type	Method and Description
static <E extends Number> AbstractGroupExpression<E,E>	avg(Expression<E> expression) Create a new aggregating avg expression
static GroupByBuilder<List<?>>	groupBy(Expression<?>... keys) Create a new GroupByBuilder for the given key expressions
static <K> GroupByBuilder<K>	groupBy(Expression<K> key) Create a new GroupByBuilder for the given key expression
static <E> AbstractGroupExpression<E,List<E>>	list(Expression<E> expression) Create a new aggregating list expression
static <E,F> AbstractGroupExpression<E,List<F>>	list(GroupExpression<E,F> groupExpression)
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,V>>	map(Expression<K> key, Expression<V> value) Create a new aggregating map expression using a backing LinkedHashMap
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,U>>	map(Expression<K> key, GroupExpression<V,U> value) Create a new aggregating map expression using a backing LinkedHashMap
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<T,V>>	map(GroupExpression<K,T> key, Expression<V> value) Create a new aggregating map expression using a backing LinkedHashMap
static <K,V,T,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<T,U>>	map(GroupExpression<K,T> key, GroupExpression<V,U> value) Create a new aggregating map expression using a backing LinkedHashMap
static <E extends Comparable<? super E>> AbstractGroupExpression<E,E>	max(Expression<E> expression) Create a new aggregating max expression
static <E extends Comparable<? super E>> AbstractGroupExpression<E,E>	min(Expression<E> expression) Create a new aggregating min expression
static <E> AbstractGroupExpression<E,Set<E>>	set(Expression<E> expression) Create a new aggregating set expression using a backing LinkedHashSet
static <E,F> GroupExpression<E,Set<F>>	set(GroupExpression<E,F> groupExpression)
static <K extends Comparable<? super K>,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,V>>	sortedMap(Expression<K> key, Expression<V> value) Create a new aggregating map expression using a backing TreeMap
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,V>>	sortedMap(Expression<K> key, Expression<V> value, Comparator<? super K> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <K extends Comparable<? super K>,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,U>>	sortedMap(Expression<K> key, GroupExpression<V,U> value) Create a new aggregating map expression using a backing TreeMap
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,U>>	sortedMap(Expression<K> key, GroupExpression<V,U> value, Comparator<? super U> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <K extends Comparable<? super K>,V,T extends Comparable<? super T>> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,V>>	sortedMap(GroupExpression<K,T> key, Expression<V> value) Create a new aggregating map expression using a backing TreeMap
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,V>>	sortedMap(GroupExpression<K,T> key, Expression<V> value, Comparator<? super K> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <K extends Comparable<? super K>,V,T extends Comparable<? super T>,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,U>>	sortedMap(GroupExpression<K,T> key, GroupExpression<V,U> value) Create a new aggregating map expression using a backing TreeMap
static <K,V,T,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,U>>	sortedMap(GroupExpression<K,T> key, GroupExpression<V,U> value, Comparator<? super T> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <E extends Comparable<? super E>> AbstractGroupExpression<E,SortedSet<E>>	sortedSet(Expression<E> expression) Create a new aggregating set expression using a backing TreeSet
static <E> AbstractGroupExpression<E,SortedSet<E>>	sortedSet(Expression<E> expression, Comparator<? super E> comparator) Create a new aggregating set expression using a backing TreeSet using the given comparator
static <E,F extends Comparable<? super F>> GroupExpression<E,SortedSet<F>>	sortedSet(GroupExpression<E,F> groupExpression) Create a new aggregating set expression using a backing TreeSet
static <E,F> GroupExpression<E,SortedSet<F>>	sortedSet(GroupExpression<E,F> groupExpression, Comparator<? super F> comparator) Create a new aggregating set expression using a backing TreeSet using the given comparator
static <E extends Number> AbstractGroupExpression<E,E>	sum(Expression<E> expression) Create a new aggregating sum expression

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

groupBy

public static <K> GroupByBuilder<K> groupBy(Expression<K> key)

Create a new GroupByBuilder for the given key expression

Parameters:

key -

Returns:

groupBy

public static GroupByBuilder<List<?>> groupBy(Expression<?>... keys)

Create a new GroupByBuilder for the given key expressions

Parameters:

keys -

Returns:

min

public static <E extends Comparable<? super E>> AbstractGroupExpression<E,E> min(Expression<E> expression)

Create a new aggregating min expression

Parameters:

expression -

Returns:

sum

public static <E extends Number> AbstractGroupExpression<E,E> sum(Expression<E> expression)

Create a new aggregating sum expression

Parameters:

expression -

Returns:

avg

public static <E extends Number> AbstractGroupExpression<E,E> avg(Expression<E> expression)

Create a new aggregating avg expression

Parameters:

expression -

Returns:

max

public static <E extends Comparable<? super E>> AbstractGroupExpression<E,E> max(Expression<E> expression)

Create a new aggregating max expression

Parameters:

expression -

Returns:

list

public static <E> AbstractGroupExpression<E,List<E>> list(Expression<E> expression)

Create a new aggregating list expression

Parameters:

expression -

Returns:

list

public static <E,F> AbstractGroupExpression<E,List<F>> list(GroupExpression<E,F> groupExpression)

set

public static <E> AbstractGroupExpression<E,Set<E>> set(Expression<E> expression)

Create a new aggregating set expression using a backing LinkedHashSet

Parameters:

expression -

Returns:

set

public static <E,F> GroupExpression<E,Set<F>> set(GroupExpression<E,F> groupExpression)

sortedSet

public static <E extends Comparable<? super E>> AbstractGroupExpression<E,SortedSet<E>> sortedSet(Expression<E> expression)

Create a new aggregating set expression using a backing TreeSet

Parameters:

expression -

Returns:

sortedSet

public static <E,F extends Comparable<? super F>> GroupExpression<E,SortedSet<F>> sortedSet(GroupExpression<E,F> groupExpression)

Create a new aggregating set expression using a backing TreeSet

Parameters:

groupExpression -

Returns:

sortedSet

public static <E> AbstractGroupExpression<E,SortedSet<E>> sortedSet(Expression<E> expression,
                                                    Comparator<? super E> comparator)

Create a new aggregating set expression using a backing TreeSet using the given comparator

Parameters:

expression -

comparator -

Returns:

sortedSet

public static <E,F> GroupExpression<E,SortedSet<F>> sortedSet(GroupExpression<E,F> groupExpression,
                                              Comparator<? super F> comparator)

Create a new aggregating set expression using a backing TreeSet using the given comparator

Parameters:

groupExpression -

comparator -

Returns:

map

@WithBridgeMethods(value=Expression.class,
                   castRequired=true)
public static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,V>> map(Expression<K> key,
                                                                                                              Expression<V> value)

Create a new aggregating map expression using a backing LinkedHashMap

Parameters:

key -

value -

Returns:

map

public static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<T,V>> map(GroupExpression<K,T> key,
                                                                              Expression<V> value)

Create a new aggregating map expression using a backing LinkedHashMap

Parameters:

key -

value -

Returns:

map

public static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,U>> map(Expression<K> key,
                                                                              GroupExpression<V,U> value)

Create a new aggregating map expression using a backing LinkedHashMap

Parameters:

key -

value -

Returns:

map

public static <K,V,T,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<T,U>> map(GroupExpression<K,T> key,
                                                                                GroupExpression<V,U> value)

Create a new aggregating map expression using a backing LinkedHashMap

Parameters:

key -

value -

Returns:

sortedMap

public static <K extends Comparable<? super K>,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,V>> sortedMap(Expression<K> key,
                                                                                                                      Expression<V> value)

Create a new aggregating map expression using a backing TreeMap

Parameters:

key -

value -

Returns:

sortedMap

public static <K extends Comparable<? super K>,V,T extends Comparable<? super T>> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,V>> sortedMap(GroupExpression<K,T> key,
                                                                                                                                                      Expression<V> value)

Create a new aggregating map expression using a backing TreeMap

Parameters:

key -

value -

Returns:

sortedMap

public static <K extends Comparable<? super K>,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,U>> sortedMap(Expression<K> key,
                                                                                                                        GroupExpression<V,U> value)

Create a new aggregating map expression using a backing TreeMap

Parameters:

key -

value -

Returns:

sortedMap

public static <K extends Comparable<? super K>,V,T extends Comparable<? super T>,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,U>> sortedMap(GroupExpression<K,T> key,
                                                                                                                                                        GroupExpression<V,U> value)

Create a new aggregating map expression using a backing TreeMap

Parameters:

key -

value -

Returns:

sortedMap

public static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,V>> sortedMap(Expression<K> key,
                                                                                        Expression<V> value,
                                                                                        Comparator<? super K> comparator)

Create a new aggregating map expression using a backing TreeMap using the given comparator

Parameters:

key -

value -

comparator -

Returns:

sortedMap

public static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,V>> sortedMap(GroupExpression<K,T> key,
                                                                                          Expression<V> value,
                                                                                          Comparator<? super K> comparator)

Create a new aggregating map expression using a backing TreeMap using the given comparator

Parameters:

key -

value -

comparator -

Returns:

sortedMap

public static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,U>> sortedMap(Expression<K> key,
                                                                                          GroupExpression<V,U> value,
                                                                                          Comparator<? super U> comparator)

Create a new aggregating map expression using a backing TreeMap using the given comparator

Parameters:

key -

value -

comparator -

Returns:

sortedMap

public static <K,V,T,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,U>> sortedMap(GroupExpression<K,T> key,
                                                                                            GroupExpression<V,U> value,
                                                                                            Comparator<? super T> comparator)

Create a new aggregating map expression using a backing TreeMap using the given comparator

Parameters:

key -

value -

comparator -

Returns: