Interface JPQLQueryFactory

    • Method Detail

      • delete

        DeleteClause<?> delete​(EntityPath<?> path)
        Create a new DELETE clause
        Parameters:
        path - entity to delete from
        Returns:
        delete clause
      • select

        <T> JPQLQuery<T> select​(Expression<T> expr)
        Create a new JPQLQuery instance with the given projection
        Type Parameters:
        T -
        Parameters:
        expr - projection
        Returns:
        select(expr)
      • select

        JPQLQuery<Tuple> select​(Expression<?>... exprs)
        Create a new JPQLQuery instance with the given projection
        Parameters:
        exprs - projection
        Returns:
        select(exprs)
      • selectDistinct

        <T> JPQLQuery<T> selectDistinct​(Expression<T> expr)
        Create a new JPQLQuery instance with the given projection
        Type Parameters:
        T -
        Parameters:
        expr - projection
        Returns:
        select(distinct expr)
      • selectDistinct

        JPQLQuery<Tuple> selectDistinct​(Expression<?>... exprs)
        Create a new JPQLQuery instance with the given projection
        Parameters:
        exprs - projection
        Returns:
        select(distinct exprs)
      • selectOne

        JPQLQuery<java.lang.Integer> selectOne()
        Create a new JPQLQuery instance with the projection one
        Returns:
        select(1)
      • selectZero

        JPQLQuery<java.lang.Integer> selectZero()
        Create a new JPQLQuery instance with the projection zero
        Returns:
        select(0)
      • selectFrom

        <T> JPQLQuery<T> selectFrom​(EntityPath<T> from)
        Create a new JPQLQuery instance with the given source and projection
        Type Parameters:
        T -
        Parameters:
        from - projection and source
        Returns:
        select(from).from(from)
      • from

        JPQLQuery<?> from​(EntityPath<?> from)
        Create a new Query with the given source
        Parameters:
        from - from
        Returns:
        from(from)
      • from

        JPQLQuery<?> from​(EntityPath<?>... from)
        Create a new Query with the given source
        Parameters:
        from - from
        Returns:
        from(from)
      • update

        UpdateClause<?> update​(EntityPath<?> path)
        Create a new UPDATE clause
        Parameters:
        path - entity to update
        Returns:
        update clause
      • insert

        InsertClause<?> insert​(EntityPath<?> path)
        Create a new INSERT clause
        Parameters:
        path - entity to insert to
        Returns:
        insert clause