com.querydsl.jpa.JPQLSubQuery Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of querydsl-jpa Show documentation
JPA support for Querydsl
The newest version!
package com.querydsl.jpa;

import com.querydsl.core.QueryMetadata;
import com.querydsl.core.QueryModifiers;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.CollectionExpression;
import com.querydsl.core.types.EntityPath;
import com.querydsl.core.types.Expression;
import com.querydsl.core.types.MapExpression;
import com.querydsl.core.types.OrderSpecifier;
import com.querydsl.core.types.ParamExpression;
import com.querydsl.core.types.Path;
import com.querydsl.core.types.Predicate;
import com.querydsl.core.types.SubQueryExpression;
import com.querydsl.core.types.Visitor;
import com.querydsl.core.types.dsl.BooleanExpression;
import com.querydsl.core.types.dsl.BooleanOperation;
import java.util.Collection;

public interface JPQLSubQuery extends SubQueryExpression {

  JPQLSubQuery clone();

   JPQLSubQuery select(Expression expr);

  JPQLSubQuery select(Expression... exprs);

  JPQLSubQuery fetchJoin();

  JPQLSubQuery from(EntityPath arg);

  JPQLSubQuery from(EntityPath... args);

   JPQLSubQuery from(CollectionExpression target, Path
 alias);

  
 JPQLSubQuery innerJoin(CollectionExpression target);

  
 JPQLSubQuery innerJoin(CollectionExpression target, Path
 alias);

  
 JPQLSubQuery innerJoin(EntityPath
 target);

  
 JPQLSubQuery innerJoin(EntityPath
 target, Path
 alias);

  
 JPQLSubQuery innerJoin(MapExpression target);

  
 JPQLSubQuery innerJoin(MapExpression target, Path
 alias);

  
 JPQLSubQuery join(CollectionExpression target);

  
 JPQLSubQuery join(CollectionExpression target, Path
 alias);

  
 JPQLSubQuery join(EntityPath
 target);

  
 JPQLSubQuery join(EntityPath
 target, Path
 alias);

  
 JPQLSubQuery join(MapExpression target);

  
 JPQLSubQuery join(MapExpression target, Path
 alias);

  
 JPQLSubQuery leftJoin(CollectionExpression target);

  
 JPQLSubQuery leftJoin(CollectionExpression target, Path
 alias);

  
 JPQLSubQuery leftJoin(EntityPath
 target);

  
 JPQLSubQuery leftJoin(EntityPath
 target, Path
 alias);

  
 JPQLSubQuery leftJoin(MapExpression target);

  
 JPQLSubQuery leftJoin(MapExpression target, Path
 alias);

  
 JPQLSubQuery rightJoin(CollectionExpression target);

  
 JPQLSubQuery rightJoin(CollectionExpression target, Path
 alias);

  
 JPQLSubQuery rightJoin(EntityPath
 target);

  
 JPQLSubQuery rightJoin(EntityPath
 target, Path
 alias);

  
 JPQLSubQuery rightJoin(MapExpression target);

  
 JPQLSubQuery rightJoin(MapExpression target, Path
 alias);

  JPQLSubQuery on(Predicate condition);

  JPQLSubQuery on(Predicate... conditions);

  BooleanExpression contains(Expression right);

  BooleanExpression contains(T constant);

  BooleanExpression exists();

  BooleanExpression eq(Expression expr);

  BooleanExpression eq(T constant);

  BooleanExpression ne(Expression expr);

  BooleanExpression ne(T constant);

  BooleanExpression notExists();

  BooleanExpression lt(Expression expr);

  BooleanExpression lt(T constant);

  BooleanExpression gt(Expression expr);

  BooleanExpression gt(T constant);

  BooleanExpression loe(Expression expr);

  BooleanExpression loe(T constant);

  BooleanExpression goe(Expression expr);

  BooleanExpression goe(T constant);

  BooleanOperation isNull();

  BooleanOperation isNotNull();

  @Override
  QueryMetadata getMetadata();

  @Override
   R accept(Visitor v, C context);

  @Override
  Class getType();

  BooleanExpression in(Collection right);

  BooleanExpression in(T... right);

  /**
   * Set the Query to return distinct results
   *
   * @return the current object
   */
  JPQLSubQuery distinct();

  /**
   * Add a single grouping expression
   *
   * @param e group by expression
   * @return the current object
   */
  JPQLSubQuery groupBy(Expression e);

  /**
   * Add grouping/aggregation expressions
   *
   * @param o group by expressions
   * @return the current object
   */
  JPQLSubQuery groupBy(Expression... o);

  /**
   * Add a single filter for aggregation
   *
   * @param e having condition
   * @return the current object
   */
  JPQLSubQuery having(Predicate e);

  /**
   * Add filters for aggregation
   *
   * @param o having conditions
   * @return the current object
   */
  JPQLSubQuery having(Predicate... o);

  /**
   * Add a single order expression
   *
   * @param o order
   * @return the current object
   */
  JPQLSubQuery orderBy(OrderSpecifier o);

  /**
   * Add order expressions
   *
   * @param o order
   * @return the current object
   */
  JPQLSubQuery orderBy(OrderSpecifier... o);

  /**
   * Add the given filter condition
   *
   * 
Skips null arguments
   *
   * @param o filter conditions to be added
   * @return the current object
   */
  JPQLSubQuery where(Predicate o);

  /**
   * Add the given filter conditions
   *
   * 
Skips null arguments
   *
   * @param o filter conditions to be added
   * @return the current object
   */
  JPQLSubQuery where(Predicate... o);

  /**
   * Defines the limit / max results for the query results
   *
   * @param limit max rows
   * @return the current object
   */
  JPQLSubQuery limit(long limit);

  /**
   * Defines the offset for the query results
   *
   * @param offset row offset
   * @return the current object
   */
  JPQLSubQuery offset(long offset);

  /**
   * Defines both limit and offset of the query results, use {@link QueryModifiers#EMPTY} to apply
   * no paging.
   *
   * @param modifiers query modifiers
   * @return the current object
   */
  JPQLSubQuery restrict(QueryModifiers modifiers);

  /**
   * Set the given parameter to the given value
   *
   * @param 

   * @param param param
   * @param value binding
   * @return the current object
   */
  
 JPQLSubQuery set(ParamExpression param, P value);
}