示例#1
0
  /**
   * Process a particular association owned by the entity
   *
   * @param associationType The type representing the association to be processed.
   * @param persister The owner of the association to be processed.
   * @param propertyNumber The property number for the association (relative to the persister).
   * @param alias The entity alias
   * @param path The path to the association
   * @param nullable is the association nullable (which I think is supposed to indicate inner/outer
   *     join semantics).
   * @param currentDepth The current join depth
   * @throws org.hibernate.MappingException ???
   */
  private void walkEntityAssociationTree(
      final AssociationType associationType,
      final OuterJoinLoadable persister,
      final int propertyNumber,
      final String alias,
      final PropertyPath path,
      final boolean nullable,
      final int currentDepth)
      throws MappingException {
    String[] aliasedLhsColumns =
        JoinHelper.getAliasedLHSColumnNames(
            associationType, alias, propertyNumber, persister, getFactory());
    String[] lhsColumns =
        JoinHelper.getLHSColumnNames(associationType, propertyNumber, persister, getFactory());
    String lhsTable = JoinHelper.getLHSTableName(associationType, propertyNumber, persister);

    PropertyPath subPath = path.append(persister.getSubclassPropertyName(propertyNumber));
    JoinType joinType =
        getJoinType(
            persister,
            subPath,
            propertyNumber,
            associationType,
            persister.getFetchMode(propertyNumber),
            persister.getCascadeStyle(propertyNumber),
            lhsTable,
            lhsColumns,
            nullable,
            currentDepth);
    addAssociationToJoinTreeIfNecessary(
        associationType, aliasedLhsColumns, alias, subPath, currentDepth, joinType);
  }
示例#2
0
 /**
  * Walk the association tree for an entity, adding associations which should be join fetched to
  * the {@link #associations} inst var. This form is the entry point into the walking for a given
  * entity, starting the recursive calls into {@link
  * #walkEntityTree(org.hibernate.persister.entity.OuterJoinLoadable, String, PropertyPath ,int)}.
  *
  * @param persister The persister representing the entity to be walked.
  * @param alias The (root) alias to use for this entity/persister.
  * @param path The property path to the entity being walked
  * @param currentDepth The current join depth
  * @throws org.hibernate.MappingException ???
  */
 private void walkEntityTree(
     final OuterJoinLoadable persister,
     final String alias,
     final PropertyPath path,
     final int currentDepth)
     throws MappingException {
   int n = persister.countSubclassProperties();
   for (int i = 0; i < n; i++) {
     Type type = persister.getSubclassPropertyType(i);
     if (type.isAssociationType()) {
       walkEntityAssociationTree(
           (AssociationType) type,
           persister,
           i,
           alias,
           path,
           persister.isSubclassPropertyNullable(i),
           currentDepth);
     } else if (type.isComponentType()) {
       walkComponentTree(
           (CompositeType) type,
           i,
           0,
           persister,
           alias,
           path.append(persister.getSubclassPropertyName(i)),
           currentDepth);
     }
   }
 }
示例#3
0
  /**
   * Walk the association tree for an entity, adding associations which should be join fetched to
   * the {@link #associations} inst var. This form is the entry point into the walking for a given
   * entity, starting the recursive calls into {@link
   * #walkEntityTree(org.hibernate.persister.entity.OuterJoinLoadable, String, PropertyPath ,int)}.
   *
   * @param persister The persister representing the entity to be walked.
   * @param alias The (root) alias to use for this entity/persister.
   * @param path The property path to the entity being walked
   * @param currentDepth The current join depth
   * @throws org.hibernate.MappingException ???
   */
  private void walkEntityTree(
      final OuterJoinLoadable persister,
      final String alias,
      final PropertyPath path,
      final int currentDepth)
      throws MappingException {
    int n = persister.countSubclassProperties();
    for (int i = 0; i < n; i++) {
      Type type = persister.getSubclassPropertyType(i);
      if (type.isAssociationType()) {
        walkEntityAssociationTree(
            (AssociationType) type,
            persister,
            i,
            alias,
            path,
            persister.isSubclassPropertyNullable(i),
            currentDepth);
      } else if (type.isComponentType()) {
        walkComponentTree(
            (CompositeType) type,
            i,
            0,
            persister,
            alias,
            path.append(persister.getSubclassPropertyName(i)),
            currentDepth);
      }
    }

    // if the entity has a composite identifier, see if we need to handle
    // its sub-properties separately
    final Type idType = persister.getIdentifierType();
    if (idType.isComponentType()) {
      final CompositeType cidType = (CompositeType) idType;
      if (cidType.isEmbedded()) {
        // we have an embedded composite identifier.  Most likely we need to process the composite
        // properties separately, although there is an edge case where the identifier is really
        // a simple identifier (single value) wrapped in a JPA @IdClass or even in the case of a
        // a simple identifier (single value) wrapped in a Hibernate composite type.
        //
        // We really do not have a built-in method to determine that.  However, generally the
        // persister would report that there is single, physical identifier property which is
        // explicitly at odds with the notion of "embedded composite".  So we use that for now
        if (persister.getEntityMetamodel().getIdentifierProperty().isEmbedded()) {
          walkComponentTree(cidType, -1, 0, persister, alias, path.append(""), currentDepth);
        }
      }
    }
  }