Package | Description |
---|---|
com.querydsl.core.group |
Aggregating post processing functionality
|
com.querydsl.core.group.guava |
Utilities for creating group by factory expressions for Guava collection types
|
Modifier and Type | Class and Description |
---|---|
class |
MixinGroupExpression<E,F,R>
MixinGroupExpression provides nesting support for GroupExpression instances |
Modifier and Type | Method and Description |
---|---|
static <E extends java.lang.Number> |
GroupBy.avg(Expression<E> expression)
Create a new aggregating avg expression, uses default MathContext.DECIMAL128 for average calculation
|
static <E extends java.lang.Number> |
GroupBy.avg(Expression<E> expression,
java.math.MathContext mathContext)
Create a new aggregating avg expression with a user-provided MathContext
|
static <E> AbstractGroupExpression<E,java.util.List<E>> |
GroupBy.list(Expression<E> expression)
Create a new aggregating list expression
|
static <E,F> AbstractGroupExpression<E,java.util.List<F>> |
GroupBy.list(GroupExpression<E,F> groupExpression)
Create a new aggregating list expression
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.Map<K,V>> |
GroupBy.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>,java.util.Map<K,U>> |
GroupBy.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>,java.util.Map<T,V>> |
GroupBy.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>,java.util.Map<T,U>> |
GroupBy.map(GroupExpression<K,T> key,
GroupExpression<V,U> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <E extends java.lang.Comparable<? super E>> |
GroupBy.max(Expression<E> expression)
Create a new aggregating max expression
|
static <E extends java.lang.Comparable<? super E>> |
GroupBy.min(Expression<E> expression)
Create a new aggregating min expression
|
static <E> AbstractGroupExpression<E,java.util.Set<E>> |
GroupBy.set(Expression<E> expression)
Create a new aggregating set expression using a backing LinkedHashSet
|
static <K extends java.lang.Comparable<? super K>,V> |
GroupBy.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>,java.util.SortedMap<K,V>> |
GroupBy.sortedMap(Expression<K> key,
Expression<V> value,
java.util.Comparator<? super K> comparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K extends java.lang.Comparable<? super K>,V,U> |
GroupBy.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>,java.util.SortedMap<K,U>> |
GroupBy.sortedMap(Expression<K> key,
GroupExpression<V,U> value,
java.util.Comparator<? super K> comparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K,V,T extends java.lang.Comparable<? super T>> |
GroupBy.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>,java.util.SortedMap<T,V>> |
GroupBy.sortedMap(GroupExpression<K,T> key,
Expression<V> value,
java.util.Comparator<? super T> comparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K,V,T extends java.lang.Comparable<? super T>,U> |
GroupBy.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>,java.util.SortedMap<T,U>> |
GroupBy.sortedMap(GroupExpression<K,T> key,
GroupExpression<V,U> value,
java.util.Comparator<? super T> comparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <E extends java.lang.Comparable<? super E>> |
GroupBy.sortedSet(Expression<E> expression)
Create a new aggregating set expression using a backing TreeSet
|
static <E> AbstractGroupExpression<E,java.util.SortedSet<E>> |
GroupBy.sortedSet(Expression<E> expression,
java.util.Comparator<? super E> comparator)
Create a new aggregating set expression using a backing TreeSet using the given comparator
|
static <E extends java.lang.Number> |
GroupBy.sum(Expression<E> expression)
Create a new aggregating sum expression
|
Modifier and Type | Method and Description |
---|---|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.Multimap<K,V>> |
GuavaGroupBy.multimap(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>,com.google.common.collect.Multimap<K,U>> |
GuavaGroupBy.multimap(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>,com.google.common.collect.Multimap<T,V>> |
GuavaGroupBy.multimap(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>,com.google.common.collect.Multimap<T,U>> |
GuavaGroupBy.multimap(GroupExpression<K,T> key,
GroupExpression<V,U> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<? super V>> |
GuavaGroupBy.sortedSetMultimap(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>,com.google.common.collect.SortedSetMultimap<K,V>> |
GuavaGroupBy.sortedSetMultimap(Expression<K> key,
Expression<V> value,
java.util.Comparator<? super K> keyComparator,
java.util.Comparator<? super V> valueComparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K extends java.lang.Comparable<? super K>,V,U> |
GuavaGroupBy.sortedSetMultimap(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>,com.google.common.collect.SortedSetMultimap<K,U>> |
GuavaGroupBy.sortedSetMultimap(Expression<K> key,
GroupExpression<V,U> value,
java.util.Comparator<? super K> keyComparator,
java.util.Comparator<? super U> valueComparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K,V,T extends java.lang.Comparable<? super T>> |
GuavaGroupBy.sortedSetMultimap(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>,com.google.common.collect.SortedSetMultimap<T,V>> |
GuavaGroupBy.sortedSetMultimap(GroupExpression<K,T> key,
Expression<V> value,
java.util.Comparator<? super T> comparator,
java.util.Comparator<? super V> valueComparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K,V,T extends java.lang.Comparable<? super T>,U extends java.lang.Comparable<? super U>> |
GuavaGroupBy.sortedSetMultimap(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>,com.google.common.collect.SortedSetMultimap<T,U>> |
GuavaGroupBy.sortedSetMultimap(GroupExpression<K,T> key,
GroupExpression<V,U> value,
java.util.Comparator<? super T> keyComparator,
java.util.Comparator<? super U> valueComparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <R,C,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,C,V>> |
GuavaGroupBy.sortedTable(Expression<R> row,
Expression<C> column,
Expression<V> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,C,W>> |
GuavaGroupBy.sortedTable(Expression<R> row,
Expression<C> column,
GroupExpression<V,W> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,W,V>> |
GuavaGroupBy.sortedTable(Expression<R> row,
GroupExpression<C,W> column,
Expression<V> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super W> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.sortedTable(Expression<R> row,
GroupExpression<C,X> column,
GroupExpression<V,W> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super X> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,T,U,W> |
GuavaGroupBy.sortedTable(GroupExpression<R,T> row,
GroupExpression<C,U> column,
GroupExpression<V,W> value,
java.util.Comparator<? super T> rowComparator,
java.util.Comparator<? super U> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<W,C,V>> |
GuavaGroupBy.sortedTable(GroupExpression<R,W> row,
Expression<C> column,
Expression<V> value,
java.util.Comparator<? super W> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.sortedTable(GroupExpression<R,W> row,
GroupExpression<C,X> column,
Expression<V> value,
java.util.Comparator<? super W> rowComparator,
java.util.Comparator<? super X> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.sortedTable(GroupExpression<R,X> row,
Expression<C> column,
GroupExpression<V,W> value,
java.util.Comparator<? super X> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,C,V>> |
GuavaGroupBy.table(Expression<R> row,
Expression<C> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,C,W>> |
GuavaGroupBy.table(Expression<R> row,
Expression<C> column,
GroupExpression<V,W> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,W,V>> |
GuavaGroupBy.table(Expression<R> row,
GroupExpression<C,W> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.table(Expression<R> row,
GroupExpression<C,X> column,
GroupExpression<V,W> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,T,U,W> |
GuavaGroupBy.table(GroupExpression<R,T> row,
GroupExpression<C,U> column,
GroupExpression<V,W> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<W,C,V>> |
GuavaGroupBy.table(GroupExpression<R,W> row,
Expression<C> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.table(GroupExpression<R,W> row,
GroupExpression<C,X> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.table(GroupExpression<R,X> row,
Expression<C> column,
GroupExpression<V,W> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
Copyright © 2007–2021 Querydsl. All rights reserved.