org.hibernate.query.criteria.internal.expression.function.AggregationFunction Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of hibernate-core Show documentation
Hibernate's core ORM functionality
There is a newer version: 7.0.0.Alpha1
/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or .
 */
package org.hibernate.query.criteria.internal.expression.function;

import java.io.Serializable;
import java.util.List;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Root;

import org.hibernate.query.criteria.internal.CriteriaBuilderImpl;
import org.hibernate.query.criteria.internal.compile.RenderingContext;
import org.hibernate.query.criteria.internal.expression.LiteralExpression;

/**
 * Models SQL aggregation functions (MIN, MAX, COUNT, etc).
 *
 * @author Steve Ebersole
 */
public class AggregationFunction
		extends ParameterizedFunctionExpression
		implements Serializable {

	/**
	 * Constructs an aggregation function with a single literal argument.
	 *
	 * @param criteriaBuilder The query builder instance.
	 * @param returnType The function return type.
	 * @param functionName The name of the function.
	 * @param argument The literal argument
	 */
	@SuppressWarnings({ "unchecked" })
	public AggregationFunction(
			CriteriaBuilderImpl criteriaBuilder,
			Class returnType,
			String functionName,
			Object argument) {
		this( criteriaBuilder, returnType, functionName, new LiteralExpression( criteriaBuilder, argument ) );
	}

	/**
	 * Constructs an aggregation function with a single literal argument.
	 *
	 * @param criteriaBuilder The query builder instance.
	 * @param returnType The function return type.
	 * @param functionName The name of the function.
	 * @param argument The argument
	 */
	public AggregationFunction(
			CriteriaBuilderImpl criteriaBuilder,
			Class returnType,
			String functionName,
			Expression argument) {
		super( criteriaBuilder, returnType, functionName, argument );
	}

	@Override
	public boolean isAggregation() {
		return true;
	}

	@Override
	protected boolean isStandardJpaFunction() {
		return true;
	}

	/**
	 * Implementation of a COUNT function providing convenience in construction.
	 * 
	 * Parameterized as {@link Long} because thats what JPA states
	 * that the return from COUNT should be.
	 */
	public static class COUNT extends AggregationFunction {
		public static final String NAME = "count";

		private final boolean distinct;

		public COUNT(CriteriaBuilderImpl criteriaBuilder, Expression expression, boolean distinct) {
			super( criteriaBuilder, Long.class, NAME , expression );
			this.distinct = distinct;
		}

		@Override
		protected void renderArguments(StringBuilder buffer, RenderingContext renderingContext) {
			if ( isDistinct() ) {
				buffer.append("distinct ");
			}
			else {
	            // If function specifies a single non-distinct entity with ID, its alias would normally be rendered, which ends up
	            // converting to the column(s) associated with the entity's ID in the rendered SQL.  However, some DBs don't support
	            // the multiple columns that would end up here for entities with composite IDs.  So, since we modify the query to
	            // instead specify star since that's functionally equivalent and supported by all DBs.
				List> argExprs = getArgumentExpressions();
				if (argExprs.size() == 1) {
					Expression argExpr = argExprs.get(0);
					if (argExpr instanceof Root) {
						Root root = (Root)argExpr;
						if (!root.getModel().hasSingleIdAttribute()) {
							buffer.append('*');
							return;
						}
					}
				}
			}
			super.renderArguments(buffer, renderingContext);
		}

		public boolean isDistinct() {
			return distinct;
		}

	}

	/**
     * Implementation of a AVG function providing convenience in construction.
     * 

     * Parameterized as {@link Double} because thats what JPA states that the return from AVG should be.
	 */
	public static class AVG extends AggregationFunction {
		public static final String NAME = "avg";

		public AVG(CriteriaBuilderImpl criteriaBuilder, Expression expression) {
			super( criteriaBuilder, Double.class, NAME, expression );
		}
	}

	/**
	 * Implementation of a SUM function providing convenience in construction.
	 * 

	 * Parameterized as {@link Number N extends Number} because thats what JPA states
	 * that the return from SUM should be.
	 */
	public static class SUM extends AggregationFunction {
		public static final String NAME = "sum";

		@SuppressWarnings({ "unchecked" })
		public SUM(CriteriaBuilderImpl criteriaBuilder, Expression expression) {
			super( criteriaBuilder, (Class)expression.getJavaType(), NAME , expression);
			// force the use of a ValueHandler
			resetJavaType( expression.getJavaType() );
		}

		public SUM(CriteriaBuilderImpl criteriaBuilder, Expression expression, Class returnType) {
			super( criteriaBuilder, returnType, NAME , expression);
			// force the use of a ValueHandler
			resetJavaType( returnType );
		}
	}

	/**
	 * Implementation of a MIN function providing convenience in construction.
	 * 

	 * Parameterized as {@link Number N extends Number} because thats what JPA states
	 * that the return from MIN should be.
	 */
	public static class MIN extends AggregationFunction {
		public static final String NAME = "min";

		@SuppressWarnings({ "unchecked" })
		public MIN(CriteriaBuilderImpl criteriaBuilder, Expression expression) {
			super( criteriaBuilder, ( Class ) expression.getJavaType(), NAME , expression);
		}
	}

	/**
	 * Implementation of a MAX function providing convenience in construction.
	 * 
	 * Parameterized as {@link Number N extends Number} because thats what JPA states
	 * that the return from MAX should be.
	 */
	public static class MAX extends AggregationFunction {
		public static final String NAME = "max";

		@SuppressWarnings({ "unchecked" })
		public MAX(CriteriaBuilderImpl criteriaBuilder, Expression expression) {
			super( criteriaBuilder, ( Class ) expression.getJavaType(), NAME , expression);
		}
	}

	/**
	 * Models  the MIN function in terms of non-numeric expressions.
	 *
	 * @see MIN
	 */
	public static class LEAST> extends AggregationFunction {
		public static final String NAME = "min";

		@SuppressWarnings({ "unchecked" })
		public LEAST(CriteriaBuilderImpl criteriaBuilder, Expression expression) {
			super( criteriaBuilder, ( Class ) expression.getJavaType(), NAME , expression);
		}
	}

	/**
	 * Models  the MAX function in terms of non-numeric expressions.
	 *
	 * @see MAX
	 */
	public static class GREATEST> extends AggregationFunction {
		public static final String NAME = "max";

		@SuppressWarnings({ "unchecked" })
		public GREATEST(CriteriaBuilderImpl criteriaBuilder, Expression expression) {
			super( criteriaBuilder, ( Class ) expression.getJavaType(), NAME , expression);
		}
	}
}