Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Hibernate, Relational Persistence for Idiomatic Java
    *
    * Copyright (c) 2009 by Red Hat Inc and/or its affiliates or by
    * third-party contributors as indicated by either @author tags or express
    * copyright attribution statements applied by the authors.  All
    * third-party contributions are distributed under license by Red Hat Inc.
    *
    * This copyrighted material is made available to anyone wishing to use, modify,
   * copy, or redistribute it subject to the terms and conditions of the GNU
   * Lesser General Public License, as published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
   * for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with this distribution; if not, write to:
   * Free Software Foundation, Inc.
   * 51 Franklin Street, Fifth Floor
   * Boston, MA  02110-1301  USA
   */
  package org.hibernate.ejb.criteria;
  
  import java.util.Arrays;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
Hibernate implementation of the JPA javax.persistence.criteria.CriteriaBuilder contract.

Author(s):
Steve Ebersole
  
  public class CriteriaBuilderImpl implements CriteriaBuilderSerializable {
  
  	public CriteriaBuilderImpl(EntityManagerFactoryImpl entityManagerFactory) {
  		this. = entityManagerFactory;
  	}

Provides protected access to the underlying org.hibernate.ejb.EntityManagerFactoryImpl.

 
 	}

 
 		return new CriteriaQueryImpl<Object>( thisObject.class );
 	}

 
 	public <T> CriteriaQuery<T> createQuery(Class<T> resultClass) {
 		return new CriteriaQueryImpl<T>( thisresultClass );
 	}

 
 		return new CriteriaQueryImpl<Tuple>( thisTuple.class );
 	}

Package-protected method to centralize checking of criteria query multiselects as defined by the javax.persistence.criteria.CriteriaQuery.multiselect(java.util.List) method.

Parameters:
selections The selection varargs to check
Throws:
java.lang.IllegalArgumentException If, as per javax.persistence.criteria.CriteriaQuery.multiselect(java.util.List) documentation, "An argument to the multiselect method must not be a tuple- or array-valued compound selection item."
 
 	void checkMultiselect(List<Selection<?>> selections) {
 		for ( Selection<?> selection : selections ) {
 			if ( selection.isCompoundSelection() ) {
 				if ( selection.getJavaType().isArray() ) {
 							"multiselect selections cannot contain " +
 									"compound array-valued elements"
 					);
 				}
 				if ( Tuple.class.isAssignableFromselection.getJavaType() ) ) {
 							"multiselect selections cannot contain " +
 									"compound tuple-valued elements"
 					);
 				}
 			}
 		}
 	}

 
 	public CompoundSelection<Tupletuple(Selection<?>... selections) {
 		return tuple( Arrays.asListselections ) );
 	}

Version of tuple(javax.persistence.criteria.Selection[]) taking a list.

Parameters:
selections List of selections.
Returns:
The tuple compound selection
 
 	public CompoundSelection<Tupletuple(List<Selection<?>> selections) {
 		checkMultiselectselections );
 		return new CompoundSelectionImpl<Tuple>( thisTuple.classselections );
 	}

 
 	public CompoundSelection<Object[]> array(Selection<?>... selections) {
 		return array( Arrays.asListselections ) );
 	}

Version of array(javax.persistence.criteria.Selection[]) taking a list of selections.

Parameters:
selections List of selections.
Returns:
The array compound selection
 
 	public CompoundSelection<Object[]> array(List<Selection<?>> selections) {
 		return arrayObject[].classselections );
 	}

Version of array(javax.persistence.criteria.Selection[]) taking a list of selections, as well as the type of array.

Parameters:
type The type of array
selections List of selections.
Returns:
The array compound selection
 
 	public <Y> CompoundSelection<Y> array(Class<Y> typeList<Selection<?>> selections) {
 		checkMultiselectselections );
 		return new CompoundSelectionImpl<Y>( thistypeselections );
 	}

 
 	public <Y> CompoundSelection<Y> construct(Class<Y> resultSelection<?>... selections) {
 		return constructresult, Arrays.asListselections ) );
 	}

Version of construct(java.lang.Class,javax.persistence.criteria.Selection[]) taking the to-be-constructed type as well as a list of selections.

Parameters:
result The result class to be constructed.
selections The selections to use in the constructor call.
Returns:
The view compound selection.
 
 	public <Y> CompoundSelection<Y> construct(Class<Y> resultList<Selection<?>> selections) {
 		checkMultiselectselections );
 		return new CompoundSelectionImpl<Y>( thisresultselections );
 	}
 
 
 	// ordering ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
 	public Order asc(Expression<?> x) {
 		return new OrderImplxtrue );
 	}

 
 	public Order desc(Expression<?> x) {
 		return new OrderImplxfalse );
 	}
 
 
 	// predicates ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 	public Predicate wrap(Expression<Booleanexpression) {
 		if ( Predicate.class.isInstanceexpression ) ) {
 			return ( (Predicateexpression );
 		}
 		else if ( PathImplementor.class.isInstanceexpression ) ) {
 			return new BooleanAssertionPredicatethisexpression. );
 		}
 		else {
 			return new BooleanExpressionPredicatethisexpression );
 		}
 	}

 
 	public Predicate not(Expression<Booleanexpression) {
 		return wrapexpression ).not();
 	}

 
 		return new CompoundPredicatethis..xy );
 	}

 
 		return new CompoundPredicatethis..xy );
 	}

 
 	public Predicate and(Predicate... restrictions) {
 		return new CompoundPredicatethis..restrictions );
 	}

 
 	public Predicate or(Predicate... restrictions) {
 		return new CompoundPredicatethis..restrictions );
 	}

 
 	public Predicate conjunction() {
 		return new CompoundPredicatethis.. );
 	}

 
 	public Predicate disjunction() {
 		return new CompoundPredicatethis.. );
 	}

 
 	public Predicate isTrue(Expression<Booleanexpression) {
 		if ( CompoundPredicate.class.isInstanceexpression ) ) {
 			final CompoundPredicate predicate = (CompoundPredicateexpression;
 			if ( predicate.getExpressions().size() == 0 ) {
 						this,
 				);
 			}
 			return predicate;
 		}
 		else if ( Predicate.class.isInstanceexpression ) ) {
 			return (Predicateexpression;
 		}
 		return new BooleanAssertionPredicatethisexpression. );
 	}

 
 	public Predicate isFalse(Expression<Booleanexpression) {
 		if ( CompoundPredicate.class.isInstanceexpression ) ) {
 			final CompoundPredicate predicate = (CompoundPredicateexpression;
 			if ( predicate.getExpressions().size() == 0 ) {
 						this,
 				);
 			}
 			predicate.not();
 			return predicate;
 		}
 		else if ( Predicate.class.isInstanceexpression ) ) {
 			final Predicate predicate = (Predicateexpression;
 			predicate.not();
 			return predicate;
 		}
 		return new BooleanAssertionPredicatethisexpression. );
 	}

s
 
 	public Predicate isNull(Expression<?> x) {
 		return new NullnessPredicatethisx );
 	}

 
 	public Predicate isNotNull(Expression<?> x) {
 		return isNullx ).not();
 	}

 
 	public Predicate equal(Expression<?> xExpression<?> y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate notEqual(Expression<?> xExpression<?> y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate equal(Expression<?> xObject y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate notEqual(Expression<?> xObject y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> xExpression<? extends Y> y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate lessThan(
 			Expression<? extends Y> x,
 			Expression<? extends Y> y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(
 			Expression<? extends Y> x,
 			Expression<? extends Y> y) {
 		//noinspection SuspiciousNameCombination
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(
 			Expression<? extends Y> x,
 			Expression<? extends Y> y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate greaterThan(
 			Expression<? extends Y> x,
 			Y y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate lessThan(
 			Expression<? extends Y> x,
 			Y y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(
 			Expression<? extends Y> x,
 			Y y) {
 		//noinspection SuspiciousNameCombination
 	}

 
 	public<Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(
 			Expression<? extends Y> x,
 			Y y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate gt(Expression<? extends NumberxExpression<? extends Numbery) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate lt(Expression<? extends NumberxExpression<? extends Numbery) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate ge(Expression<? extends NumberxExpression<? extends Numbery) {
 		//noinspection SuspiciousNameCombination
 	}

 
 	public Predicate le(Expression<? extends NumberxExpression<? extends Numbery) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate gt(Expression<? extends NumberxNumber y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate lt(Expression<? extends NumberxNumber y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public Predicate ge(Expression<? extends NumberxNumber y) {
 		//noinspection SuspiciousNameCombination
 	}

 
 	public Predicate le(Expression<? extends NumberxNumber y) {
 		//noinspection SuspiciousNameCombination
 		return new ComparisonPredicatethis.xy );
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate between(
 			Expression<? extends Y> expression,
 			Y lowerBound,
 			Y upperBound) {
 		return new BetweenPredicate<Y>( thisexpressionlowerBoundupperBound );
 	}

 
 	public <Y extends Comparable<? super Y>> Predicate between(
 			Expression<? extends Y> expression,
 			Expression<? extends Y> lowerBound,
 			Expression<? extends Y> upperBound) {
 		return new BetweenPredicate<Y>( thisexpressionlowerBoundupperBound );
 	}

 
 	public <T> In<T> in(Expression<? extends T> expression) {
 		return new InPredicate<T>( thisexpression );
 	}
 
 	public <T> In<T> in(Expression<? extends T> expressionExpression<? extends T>... values) {
 		return new InPredicate<T>( thisexpressionvalues );
 	}
 
 	public <T> In<T> in(Expression<? extends T> expression, T... values) {
 		return new InPredicate<T>( thisexpressionvalues );
 	}
 
 	public <T> In<T> in(Expression<? extends T> expressionCollection<T> values) {
 		return new InPredicate<T>( thisexpressionvalues );
 	}
 
 	public Predicate like(Expression<StringmatchExpressionExpression<Stringpattern) {
 		return new LikePredicatethismatchExpressionpattern );
 	}
 
 	public Predicate like(Expression<StringmatchExpressionExpression<StringpatternExpression<CharacterescapeCharacter) {
 		return new LikePredicatethismatchExpressionpatternescapeCharacter );
 	}
 
 	public Predicate like(Expression<StringmatchExpressionExpression<Stringpatternchar escapeCharacter) {
 		return new LikePredicatethismatchExpressionpatternescapeCharacter );
 	}
 
 	public Predicate like(Expression<StringmatchExpressionString pattern) {
 		return new LikePredicatethismatchExpressionpattern );
 	}
 
 	public Predicate like(Expression<StringmatchExpressionString patternExpression<CharacterescapeCharacter) {
 		return new LikePredicatethismatchExpressionpatternescapeCharacter );
 	}
 
 	public Predicate like(Expression<StringmatchExpressionString patternchar escapeCharacter) {
 		return new LikePredicatethismatchExpressionpatternescapeCharacter );
 	}
 
 	public Predicate notLike(Expression<StringmatchExpressionExpression<Stringpattern) {
 		return likematchExpressionpattern ).not();
 	}
 
 	public Predicate notLike(Expression<StringmatchExpressionExpression<StringpatternExpression<CharacterescapeCharacter) {
 		return likematchExpressionpatternescapeCharacter ).not();
 	}
 
 	public Predicate notLike(Expression<StringmatchExpressionExpression<Stringpatternchar escapeCharacter) {
 		return likematchExpressionpatternescapeCharacter ).not();
 	}
 
 	public Predicate notLike(Expression<StringmatchExpressionString pattern) {
 		return likematchExpressionpattern ).not();
 	}
 
 	public Predicate notLike(Expression<StringmatchExpressionString patternExpression<CharacterescapeCharacter) {
 		return likematchExpressionpatternescapeCharacter ).not();
 	}
 
 	public Predicate notLike(Expression<StringmatchExpressionString patternchar escapeCharacter) {
 		return likematchExpressionpatternescapeCharacter ).not();
 	}
 
 
 	// parameters ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
 	public <T> ParameterExpression<T> parameter(Class<T> paramClass) {
 		return new ParameterExpressionImpl<T>( thisparamClass );
 	}

 
 	public <T> ParameterExpression<T> parameter(Class<T> paramClassString name) {
 		return new ParameterExpressionImpl<T>( thisparamClassname );
 	}

 
 	public <T> Expression<T> literal(T value) {
 		if ( value == null ) {
 			throw new IllegalArgumentException"literal value cannot be null" );
 		}
 		return new LiteralExpression<T>( thisvalue );
 	}

 
 	public <T> Expression<T> nullLiteral(Class<T> resultClass) {
 		return new NullLiteralExpression<T>( thisresultClass );
 	}
 
 
 	// aggregate functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
 	public <N extends NumberExpression<Doubleavg(Expression<N> x) {
 		return new AggregationFunction.AVGthisx );
 	}

 
 	public <N extends NumberExpression<N> sum(Expression<N> x) {
 		return new AggregationFunction.SUM<N>( thisx );
 	}

 
 		return new AggregationFunction.SUM<Long>( thisxLong.class );
 	}

 
 		return new AggregationFunction.SUM<Double>( thisxDouble.class );
 	}

 
 	public <N extends NumberExpression<N> max(Expression<N> x) {
 		return new AggregationFunction.MAX<N>( thisx );
 	}

 
 	public <N extends NumberExpression<N> min(Expression<N> x) {
 		return new AggregationFunction.MIN<N>( thisx );
 	}

 
 	@SuppressWarnings({ "unchecked" })
 	public <X extends Comparable<? super X>> Expression<X> greatest(Expression<X> x) {
 		return new AggregationFunction.GREATESTthisx );
 	}

 
 	@SuppressWarnings({ "unchecked" })
 	public <X extends Comparable<? super X>> Expression<X> least(Expression<X> x) {
 		return new AggregationFunction.LEASTthisx );
 	}

 
 	public Expression<Longcount(Expression<?> x) {
 		return new AggregationFunction.COUNTthisxfalse );
 	}

 
 		return new AggregationFunction.COUNTthisxtrue );
 	}
 
 
 	// other functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
 	public <T> Expression<T> function(String nameClass<T> returnTypeExpression<?>... arguments) {
 		return new ParameterizedFunctionExpression<T>( thisreturnTypenamearguments );
 	}

Create a reference to a function taking no params.

Parameters:
name The function name.
returnType The return type.
Returns:
The function expression
 
 	public <T> Expression<T> function(String nameClass<T> returnType) {
 		return new BasicFunctionExpression<T>( thisreturnTypename );
 	}

 
 	public <N extends NumberExpression<N> abs(Expression<N> expression) {
 		return new AbsFunction<N>( thisexpression );
 	}

 
 	public Expression<Doublesqrt(Expression<? extends Numberexpression) {
 		return new SqrtFunctionthisexpression );
 	}
 
 		return new CurrentDateFunctionthis );
 	}
 
 		return new CurrentTimestampFunctionthis );
 	}
 
 		return new CurrentTimeFunctionthis );
 	}
 
 	public Expression<Stringsubstring(Expression<StringvalueExpression<Integerstart) {
 		return new SubstringFunctionthisvaluestart );
 	}
 
 	public Expression<Stringsubstring(Expression<Stringvalueint start) {
 		return new SubstringFunctionthisvaluestart );
 	}
 
 	public Expression<Stringsubstring(Expression<StringvalueExpression<IntegerstartExpression<Integerlength) {
 		return new SubstringFunctionthisvaluestartlength );
 	}
 
 	public Expression<Stringsubstring(Expression<Stringvalueint startint length) {
 		return new SubstringFunctionthisvaluestartlength );
 	}
 
 	public Expression<Stringtrim(Expression<StringtrimSource ) {
 		return new TrimFunctionthistrimSource );
 	}
 
 	public Expression<Stringtrim(Trimspec trimspecExpression<StringtrimSource) {
 		return new TrimFunctionthistrimspectrimSource );
 	}
 
 	public Expression<Stringtrim(Expression<CharactertrimCharacterExpression<StringtrimSource) {
 		return new TrimFunctionthistrimCharactertrimSource );
 	}
 
 	public Expression<Stringtrim(Trimspec trimspecExpression<CharactertrimCharacterExpression<StringtrimSource) {
 		return new TrimFunctionthistrimspectrimCharactertrimSource );
 	}
 
 	public Expression<Stringtrim(char trimCharacterExpression<StringtrimSource) {
 		return new TrimFunctionthistrimCharactertrimSource );
 	}
 
 	public Expression<Stringtrim(Trimspec trimspecchar trimCharacterExpression<StringtrimSource) {
 		return new TrimFunctionthistrimspectrimCharactertrimSource );
 	}
 
 	public Expression<Stringlower(Expression<Stringvalue) {
 		return new LowerFunctionthisvalue );
 	}
 
 	public Expression<Stringupper(Expression<Stringvalue) {
 		return new UpperFunctionthisvalue );
 	}
 
 	public Expression<Integerlength(Expression<Stringvalue) {
 		return new LengthFunctionthisvalue );
 	}
 
 	public Expression<Integerlocate(Expression<StringstringExpression<Stringpattern) {
 		return new LocateFunctionthispatternstring );
 	}
 
 	public Expression<Integerlocate(Expression<StringstringExpression<StringpatternExpression<Integerstart) {
 		return new LocateFunctionthispatternstringstart );
 	}
 
 	public Expression<Integerlocate(Expression<StringstringString pattern) {
 		return new LocateFunctionthispatternstring );
 	}
 
 	public Expression<Integerlocate(Expression<StringstringString patternint start) {
 		return new LocateFunctionthispatternstringstart );
 	}
 
 
 	// arithmetic operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 	public <N extends NumberExpression<N> neg(Expression<N> expression) {
 		return new UnaryArithmeticOperation<N>(
 				this,
 				expression
 		);
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public <N extends NumberExpression<N> sum(Expression<? extends N> expression1Expression<? extends N> expression2) {
 		if ( expression1 == null || expression2 == null ) {
 			throw new IllegalArgumentException"arguments to sum() cannot be null" );
 		}
 
 		final Class resultType = BinaryArithmeticOperation.determineResultTypeexpression1.getJavaType(), expression2.getJavaType() );
 
 		return new BinaryArithmeticOperation<N>(
 				this,
 				resultType,
 				expression1,
 				expression2
 		);
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public <N extends NumberExpression<N> prod(Expression<? extends N> expression1Expression<? extends N> expression2) {
 		if ( expression1 == null || expression2 == null ) {
 			throw new IllegalArgumentException"arguments to prod() cannot be null" );
 		}
 
 		final Class resultType = BinaryArithmeticOperation.determineResultTypeexpression1.getJavaType(), expression2.getJavaType() );
 
 		return new BinaryArithmeticOperation<N>(
 				this,
 				resultType,
 				expression1,
 				expression2
 		);
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public <N extends NumberExpression<N> diff(Expression<? extends N> expression1Expression<? extends N> expression2) {
 		if ( expression1 == null || expression2 == null ) {
 			throw new IllegalArgumentException"arguments to diff() cannot be null" );
 		}
 
 		final Class resultType = BinaryArithmeticOperation.determineResultTypeexpression1.getJavaType(), expression2.getJavaType() );
 
 		return new BinaryArithmeticOperation<N>(
 				this,
 				resultType,
 				expression1,
 				expression2
 		);
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public <N extends NumberExpression<N> sum(Expression<? extends N> expression, N n) {
 		if ( expression == null || n == null ) {
 			throw new IllegalArgumentException"arguments to sum() cannot be null" );
 		}
 
 		final Class resultType = BinaryArithmeticOperation.determineResultTypeexpression.getJavaType(), n.getClass() );
 
 		return new BinaryArithmeticOperation<N>(
 				this,
 				resultType,
 				expression,
 				n
 		);
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public <N extends NumberExpression<N> prod(Expression<? extends N> expression, N n) {
 		if ( expression == null || n == null ) {
 			throw new IllegalArgumentException"arguments to prod() cannot be null" );
 		}
 
 		final Class resultType = BinaryArithmeticOperation.determineResultTypeexpression.getJavaType(), n.getClass() );
 
 		return new BinaryArithmeticOperation<N>(
 				this,
 				resultType,
 				expression,
 				n
 		);
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public <N extends NumberExpression<N> diff(Expression<? extends N> expression, N n) {
 		if ( expression == null || n == null ) {
 			throw new IllegalArgumentException"arguments to diff() cannot be null" );
 		}
 
 		final Class resultType = BinaryArithmeticOperation.determineResultTypeexpression.getJavaType(), n.getClass() );
 
 		return new BinaryArithmeticOperation<N>(
 				this,
 				resultType,
 				expression,
 				n
 		);
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public <N extends NumberExpression<N> sum(N nExpression<? extends N> expression) {
 		if ( expression == null || n == null ) {
 			throw new IllegalArgumentException"arguments to sum() cannot be null" );
 		}
 
 		final Class resultType = BinaryArithmeticOperation.determineResultTypen.getClass(), expression.getJavaType() );
 
 		return new BinaryArithmeticOperation<N>(
 				this,
 				resultType,
 				n,
 				expression
 		);
 	}
 
 	@SuppressWarnings({ "unchecked" })
 	public <N extends NumberExpression<N> prod(N nExpression<? extends N> expression) {
 		if ( n == null || expression == null ) {
 			throw new IllegalArgumentException"arguments to prod() cannot be null" );
		final Class resultType = BinaryArithmeticOperation.determineResultTypen.getClass(), expression.getJavaType() );
				this,
				resultType,
				n,
				expression
		);
	@SuppressWarnings({ "unchecked" })
	public <N extends NumberExpression<N> diff(N nExpression<? extends N> expression) {
		if ( n == null || expression == null ) {
			throw new IllegalArgumentException"arguments to diff() cannot be null" );
		final Class resultType = BinaryArithmeticOperation.determineResultTypen.getClass(), expression.getJavaType() );
				this,
				resultType,
				n,
				expression
		);
	@SuppressWarnings( {"unchecked"})
	public Expression<Numberquot(Expression<? extends Numberexpression1Expression<? extends Numberexpression2) {
		if ( expression1 == null || expression2 == null ) {
			throw new IllegalArgumentException"arguments to quot() cannot be null" );
		final Class resultType = BinaryArithmeticOperation.determineResultTypeexpression1.getJavaType(), expression2.getJavaType(), true );
				this,
				resultType,
				expression1,
				expression2
		);
	@SuppressWarnings( {"unchecked"})
	public Expression<Numberquot(Expression<? extends NumberexpressionNumber number) {
		if ( expression == null || number == null ) {
			throw new IllegalArgumentException"arguments to quot() cannot be null" );
		final Class resultType = BinaryArithmeticOperation.determineResultTypeexpression.getJavaType(), number.getClass(), true );
				this,
				resultType,
				expression,
				number
		);
	@SuppressWarnings( {"unchecked"})
	public Expression<Numberquot(Number numberExpression<? extends Numberexpression) {
		if ( expression == null || number == null ) {
			throw new IllegalArgumentException"arguments to quot() cannot be null" );
		final Class resultType = BinaryArithmeticOperation.determineResultTypenumber.getClass(), expression.getJavaType(), true );
				this,
				resultType,
				number,
				expression
		);
	public Expression<Integermod(Expression<Integerexpression1Expression<Integerexpression2) {
		if ( expression1 == null || expression2 == null ) {
			throw new IllegalArgumentException"arguments to mod() cannot be null" );
				this,
				Integer.class,
				expression1,
				expression2
		);
	public Expression<Integermod(Expression<IntegerexpressionInteger integer) {
		if ( expression == null || integer == null ) {
			throw new IllegalArgumentException"arguments to mod() cannot be null" );
				this,
				Integer.class,
				expression,
				integer
		);
	public Expression<Integermod(Integer integerExpression<Integerexpression) {
		if ( integer == null || expression == null ) {
			throw new IllegalArgumentException"arguments to mod() cannot be null" );
				this,
				Integer.class,
				integer,
				expression
		);
	// casting ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public ExpressionImplementor<LongtoLong(Expression<? extends Numberexpression) {
		return ( (ExpressionImplementor<? extends Number>) expression ).asLong();
	}

	public ExpressionImplementor<IntegertoInteger(Expression<? extends Numberexpression) {
		return ( (ExpressionImplementor<? extends Number>) expression ).asInteger();
	}

	public ExpressionImplementor<FloattoFloat(Expression<? extends Numberexpression) {
		return ( (ExpressionImplementor<? extends Number>) expression ).asFloat();