com.querydsl.core.group.GroupBy Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2015, The Querydsl Team (http://www.querydsl.com/team)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.querydsl.core.group;
import java.math.MathContext;
import java.util.*;
import com.mysema.commons.lang.Pair;
import com.querydsl.core.ResultTransformer;
import com.querydsl.core.types.Expression;
import com.querydsl.core.types.Projections;
/**
* {@code GroupBy} provides factory methods for {@link ResultTransformer} and {@link GroupExpression} creation
*
* Example: Group employees by department
*
* {@code
* query.transform(
* GroupBy.groupBy(employee.department)
* .as(GroupBy.list(Projections.tuple(employee.id, employee.firstName, employee.lastName))))
* }
*
*
* @author sasa
* @author tiwe
*
*/
public class GroupBy {
/**
* Create a new GroupByBuilder for the given key expression
*
* @param key key for aggregation
* @return builder for further specification
*/
public static GroupByBuilder groupBy(Expression key) {
return new GroupByBuilder(key);
}
/**
* Create a new GroupByBuilder for the given key expressions
*
* @param keys keys for aggregation
* @return builder for further specification
*/
public static GroupByBuilder> groupBy(Expression... keys) {
return new GroupByBuilder>(Projections.list(keys));
}
/**
* Create a new aggregating min expression
*
* @param expression expression for which the minimum value will be used in the group by projection
* @return wrapper expression
*/
public static > AbstractGroupExpression min(Expression expression) {
return new GMin(expression);
}
/**
* Create a new aggregating sum expression
*
* @param expression expression a for which the accumulated sum will be used in the group by projection
* @return wrapper expression
*/
public static AbstractGroupExpression sum(Expression expression) {
return new GSum(expression);
}
/**
* Create a new aggregating avg expression, uses default MathContext.DECIMAL128 for average calculation
*
* @param expression expression for which the accumulated average value will be used in the group by projection
* @return wrapper expression
*/
public static AbstractGroupExpression avg(Expression expression) {
return new GAvg(expression);
}
/**
* Create a new aggregating avg expression with a user-provided MathContext
*
* @param expression expression for which the accumulated average value will be used in the group by projection
* @param mathContext mathContext for average calculation
* @return wrapper expression
*/
public static AbstractGroupExpression avg(Expression expression, MathContext mathContext) {
return new GAvg(expression, mathContext);
}
/**
* Create a new aggregating max expression
*
* @param expression expression for which the maximum value will be used in the group by projection
* @return wrapper expression
*/
public static > AbstractGroupExpression max(Expression expression) {
return new GMax(expression);
}
/**
* Create a new aggregating list expression
*
* @param expression values for this expression will be accumulated into a list
* @return wrapper expression
*/
public static AbstractGroupExpression> list(Expression expression) {
return new GList(expression);
}
/**
* Create a new aggregating list expression
*
* @param groupExpression values for this expression will be accumulated into a list
* @param
* @param
* @return wrapper expression
*/
public static AbstractGroupExpression> list(GroupExpression groupExpression) {
return new MixinGroupExpression>(groupExpression, new GList(groupExpression));
}
/**
* Create a new aggregating set expression using a backing LinkedHashSet
*
* @param expression values for this expression will be accumulated into a set
* @return wrapper expression
*/
public static AbstractGroupExpression> set(Expression expression) {
return GSet.createLinked(expression);
}
/**
* Create a new aggregating set expression using a backing LinkedHashSet
*
* @param groupExpression values for this expression will be accumulated into a set
* @param
* @param
* @return wrapper expression
*/
public static GroupExpression> set(GroupExpression groupExpression) {
return new MixinGroupExpression>(groupExpression, GSet.createLinked(groupExpression));
}
/**
* Create a new aggregating set expression using a backing TreeSet
*
* @param expression values for this expression will be accumulated into a set
* @return wrapper expression
*/
public static > AbstractGroupExpression> sortedSet(Expression expression) {
return GSet.createSorted(expression);
}
/**
* Create a new aggregating set expression using a backing TreeSet
*
* @param groupExpression values for this expression will be accumulated into a set
* @return wrapper expression
*/
public static > GroupExpression> sortedSet(GroupExpression groupExpression) {
return new MixinGroupExpression>(groupExpression, GSet.createSorted(groupExpression));
}
/**
* Create a new aggregating set expression using a backing TreeSet using the given comparator
*
* @param expression values for this expression will be accumulated into a set
* @param comparator comparator of the created TreeSet instance
* @return wrapper expression
*/
public static AbstractGroupExpression> sortedSet(Expression expression,
Comparator comparator) {
return GSet.createSorted(expression, comparator);
}
/**
* Create a new aggregating set expression using a backing TreeSet using the given comparator
*
* @param groupExpression values for this expression will be accumulated into a set
* @param comparator comparator of the created TreeSet instance
* @return wrapper expression
*/
public static GroupExpression> sortedSet(GroupExpression groupExpression,
Comparator comparator) {
return new MixinGroupExpression>(groupExpression, GSet.createSorted(groupExpression, comparator));
}
/**
* Create a new aggregating map expression using a backing LinkedHashMap
*
* @param key key for the map entries
* @param value value for the map entries
* @return wrapper expression
*/
public static AbstractGroupExpression,Map> map(Expression key,
Expression value) {
return GMap.createLinked(QPair.create(key, value));
}
/**
* Create a new aggregating map expression using a backing LinkedHashMap
*
* @param key key for the map entries
* @param value value for the map entries
* @return wrapper expression
*/
public static AbstractGroupExpression, Map> map(GroupExpression key,
Expression value) {
return map(key, new GOne(value));
}
/**
* Create a new aggregating map expression using a backing LinkedHashMap
*
* @param key key for the map entries
* @param value value for the map entries
* @return wrapper expression
*/
public static AbstractGroupExpression, Map> map(Expression key,
GroupExpression value) {
return map(new GOne(key), value);
}
/**
* Create a new aggregating map expression using a backing LinkedHashMap
*
* @param key key for the map entries
* @param value value for the map entries
* @return wrapper expression
*/
public static AbstractGroupExpression, Map> map(GroupExpression key,
GroupExpression value) {
return new GMap.Mixin>(key, value, GMap.createLinked(QPair.create(key, value)));
}
/**
* Create a new aggregating map expression using a backing TreeMap
*
* @param key key for the map entries
* @param value value for the map entries
* @return wrapper expression
*/
public static , V> AbstractGroupExpression, SortedMap> sortedMap(Expression key,
Expression value) {
return GMap.createSorted(QPair.create(key, value));
}
/**
* Create a new aggregating map expression using a backing TreeMap
*
* @param key key for the map entries
* @param value value for the map entries
* @return wrapper expression
*/
public static > AbstractGroupExpression, SortedMap> sortedMap(GroupExpression key,
Expression value) {
return sortedMap(key, new GOne(value));
}
/**
* Create a new aggregating map expression using a backing TreeMap
*
* @param key key for the map entries
* @param value value for the map entries
* @return wrapper expression
*/
public static , V, U> AbstractGroupExpression, SortedMap> sortedMap(Expression key,
GroupExpression value) {
return sortedMap(new GOne(key), value);
}
/**
* Create a new aggregating map expression using a backing TreeMap
*
* @param key key for the map entries
* @param value value for the map entries
* @return wrapper expression
*/
public static , U> AbstractGroupExpression, SortedMap> sortedMap(GroupExpression key,
GroupExpression value) {
return new GMap.Mixin>(key, value, GMap.createSorted(QPair.create(key, value)));
}
/**
* Create a new aggregating map expression using a backing TreeMap using the given comparator
*
* @param key key for the map entries
* @param value value for the map entries
* @param comparator comparator for the created TreeMap instances
* @return wrapper expression
*/
public static AbstractGroupExpression, SortedMap> sortedMap(Expression key,
Expression value,
Comparator comparator) {
return GMap.createSorted(QPair.create(key, value), comparator);
}
/**
* Create a new aggregating map expression using a backing TreeMap using the given comparator
*
* @param key key for the map entries
* @param value value for the map entries
* @param comparator comparator for the created TreeMap instances
* @return wrapper expression
*/
public static AbstractGroupExpression, SortedMap> sortedMap(GroupExpression key,
Expression value,
Comparator comparator) {
return sortedMap(key, new GOne(value), comparator);
}
/**
* Create a new aggregating map expression using a backing TreeMap using the given comparator
*
* @param key key for the map entries
* @param value value for the map entries
* @param comparator comparator for the created TreeMap instances
* @return wrapper expression
*/
public static AbstractGroupExpression, SortedMap> sortedMap(Expression key,
GroupExpression value,
Comparator comparator) {
return sortedMap(new GOne(key), value, comparator);
}
/**
* Create a new aggregating map expression using a backing TreeMap using the given comparator
*
* @param key key for the map entries
* @param value value for the map entries
* @param comparator comparator for the created TreeMap instances
* @return wrapper expression
*/
public static AbstractGroupExpression, SortedMap> sortedMap(GroupExpression key,
GroupExpression value,
Comparator comparator) {
return new GMap.Mixin>(key, value, GMap.createSorted(QPair.create(key, value), comparator));
}
protected GroupBy() { }
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy