Class JoinStateObject

  • All Implemented Interfaces:
    StateObject

    public class JoinStateObject
    extends AbstractStateObject
    A JOIN enables the fetching of an association as a side effect of the execution of a query. A JOIN is specified over an entity and its related entities.
    BNF: join ::= join_spec join_association_path_expression [AS] identification_variable

    A JOIN FETCH enables the fetching of an association as a side effect of the execution of a query. A JOIN FETCH is specified over an entity and its related entities.

    BNF: fetch_join ::= join_spec FETCH join_association_path_expression

    Version:
    2.4
    See Also:
    Join
    Author:
    Pascal Filion
    Since:
    2.4
    • Field Detail

      • AS_PROPERTY

        public static final java.lang.String AS_PROPERTY
        Notifies the visibility of the AS identifier has changed.
        See Also:
        Constant Field Values
      • JOIN_TYPE_PROPERTY

        public static final java.lang.String JOIN_TYPE_PROPERTY
        Notifies the join type property has changed.
        See Also:
        Constant Field Values
    • Constructor Detail

      • JoinStateObject

        public JoinStateObject​(AbstractIdentificationVariableDeclarationStateObject parent,
                               java.lang.String joinType,
                               boolean as)
        Creates a new JoinStateObject.
        Parameters:
        parent - The parent of this state object
        joinType - One of the joining types
        as - Determine whether the AS identifier is used or not
    • Method Detail

      • addAs

        public JoinStateObject addAs()
        Makes sure the AS identifier is specified.
        Returns:
        This object
      • addJoinAssociationPaths

        public void addJoinAssociationPaths​(java.util.List<java.lang.String> paths)
        Adds the given segments to the end of the join association path expression. The identification variable will not be affected.
        Parameters:
        paths - The new path expression
      • getExpression

        public Join getExpression()
        Returns the actual parsed object if this StateObject representation of the JPQL query was created by parsing an existing JPQL query.
        Specified by:
        getExpression in interface StateObject
        Overrides:
        getExpression in class AbstractStateObject
        Returns:
        The parsed object when a JPQL query is parsed and converted into a StateObject or null when the JPQL query is manually created (i.e. not from a string)
      • getIdentificationVariable

        public java.lang.String getIdentificationVariable()
        Returns the name of the identification variable that defines the join association path.
        Returns:
        The variable defining the join association path
      • getIdentificationVariableStateObject

        public IdentificationVariableStateObject getIdentificationVariableStateObject()
        Returns the state object holding the identification variable.
        Returns:
        The portion of the joining expression representing the identification variable
      • getJoinAssociationIdentificationVariable

        public StateObject getJoinAssociationIdentificationVariable()
        Returns the StateObject representing the identification variable that starts the path expression, which can be a sample identification variable, a map value, map key or map entry expression.
        Returns:
        The root of the path expression
      • getJoinType

        public java.lang.String getJoinType()
        Returns the joining type.
        Returns:
        The joining type of this joining expression
      • hasAs

        public boolean hasAs()
        Determines whether the AS identifier is used or not.
        Returns:
        true if the AS identifier is part of the expression; false otherwise
      • hasFetch

        public boolean hasFetch()
        Determines whether the identifier FETCH was parsed.
        Returns:
        true if the identifier FETCH was parsed; false otherwise
      • hasIdentificationVariable

        public boolean hasIdentificationVariable()
        Determines whether the identification variable has been defined.
        Returns:
        true if the identification has been defined; false otherwise
      • joinAssociationPaths

        public ListIterable<java.lang.String> joinAssociationPaths()
        Returns the segments in the state field path in order.
        Returns:
        An Iterator over the segments of the state field path
      • joinAssociationPathSize

        public int joinAssociationPathSize()
        Returns the number of segments in the path expression.
        Returns:
        The number of segments
      • removeNot

        public void removeNot()
        Makes sure the AS identifier is not specified.
      • setAs

        public void setAs​(boolean as)
        Sets whether the AS identifier is used or not.
        Parameters:
        as - true if the AS identifier is part of the expression; false otherwise
      • setExpression

        public void setExpression​(Join expression)
        Keeps a reference of the parsed object object, which should only be done when this object is instantiated during the conversion of a parsed JPQL query into StateObjects.
        Parameters:
        expression - The parsed object representing a JOIN expression
      • setIdentificationVariable

        public void setIdentificationVariable​(java.lang.String identificationVariable)
        Sets the name of the identification variable that defines the join association path.
        Parameters:
        identificationVariable - The new variable defining the join association path
      • setJoinAssociationIdentificationVariable

        public void setJoinAssociationIdentificationVariable​(StateObject identificationVariable)
        Sets the StateObject representing the identification variable that starts the path expression, which can be a sample identification variable, a map value, map key or map entry expression.
        Parameters:
        identificationVariable - The root of the path expression
      • setJoinAssociationPath

        public void setJoinAssociationPath​(java.lang.String path)
        Changes the path expression with the list of segments, the identification variable will also be updated with the first segment.
        Parameters:
        path - The new path expression
      • setJoinAssociationPaths

        public void setJoinAssociationPaths​(java.util.ListIterator<java.lang.String> paths)
        Changes the path expression with the list of segments, the identification variable will also be updated with the first segment.
        Parameters:
        paths - The new path expression
      • setJoinAssociationPaths

        public void setJoinAssociationPaths​(java.lang.String[] paths)
        Changes the path expression with the list of segments, the identification variable will also be updated with the first segment.
        Parameters:
        paths - The new path expression
      • setJoinType

        public void setJoinType​(java.lang.String joinType)
        Sets the joining type.
        Parameters:
        joinType - One of the joining types
      • toggleAs

        public void toggleAs()
        Toggles the usage of the AS identifier.
      • toTextInternal

        protected void toTextInternal​(java.lang.Appendable writer)
                               throws java.io.IOException
        Prints out a string representation of this StateObject, which should not be used to define a true string representation of a JPQL query but should be used for debugging purposes.
        Specified by:
        toTextInternal in class AbstractStateObject
        Parameters:
        writer - The writer used to print out the string representation
        Throws:
        java.io.IOException - This should never happens, it is only required because Appendable is used instead of any concrete class
      • validateJoinType

        protected void validateJoinType​(java.lang.String joinType)
        Validates the given join type.
        Parameters:
        joinType - One of the possible joining types