/**
   * Constructs a {@link CompositeElementGraph}.
   *
   * @param sessionFactory - the session factory.
   * @param collectionReference - the collection reference.
   * @param collectionPath - the {@link PropertyPath} for the collection.
   */
  public CompositeElementGraph(
      SessionFactoryImplementor sessionFactory,
      CollectionReference collectionReference,
      PropertyPath collectionPath) {
    super(sessionFactory);

    this.collectionReference = collectionReference;
    this.collectionPersister = collectionReference.getCollectionPersister();
    this.propertyPath = collectionPath.append("<elements>");
    this.fetchOwnerDelegate =
        new CompositeFetchOwnerDelegate(
            sessionFactory,
            (CompositeType) collectionPersister.getElementType(),
            ((QueryableCollection) collectionPersister).getElementColumnNames());
  }
Пример #2
0
  protected String generateTableAlias(int n, PropertyPath path, Joinable joinable) {
    // TODO: deal with side-effects (changes to includeInResultRowList, userAliasList,
    // resultTypeList)!!!

    // for collection-of-entity, we are called twice for given "path"
    // once for the collection Joinable, once for the entity Joinable.
    // the second call will/must "consume" the alias + perform side effects according to
    // consumesEntityAlias()
    // for collection-of-other, however, there is only one call
    // it must "consume" the alias + perform side effects, despite what consumeEntityAlias() return
    // says
    //
    // note: the logic for adding to the userAliasList is still strictly based on
    // consumesEntityAlias return value
    boolean checkForSqlAlias = joinable.consumesEntityAlias();

    if (!checkForSqlAlias && joinable.isCollection()) {
      // is it a collection-of-other (component or value) ?
      CollectionPersister collectionPersister = (CollectionPersister) joinable;
      Type elementType = collectionPersister.getElementType();
      if (elementType.isComponentType() || !elementType.isEntityType()) {
        checkForSqlAlias = true;
      }
    }

    String sqlAlias = null;

    if (checkForSqlAlias) {
      final Criteria subcriteria = translator.getCriteria(path.getFullPath());
      sqlAlias = subcriteria == null ? null : translator.getSQLAlias(subcriteria);

      if (joinable.consumesEntityAlias() && !translator.hasProjection()) {
        includeInResultRowList.add(subcriteria != null && subcriteria.getAlias() != null);
        if (sqlAlias != null) {
          if (subcriteria.getAlias() != null) {
            userAliasList.add(subcriteria.getAlias());
            resultTypeList.add(translator.getResultType(subcriteria));
          }
        }
      }
    }

    if (sqlAlias == null) {
      sqlAlias = super.generateTableAlias(n + translator.getSQLAliasCount(), path, joinable);
    }

    return sqlAlias;
  }
Пример #3
0
 protected boolean hasRestriction(PropertyPath path) {
   return translator.hasRestriction(path.getFullPath());
 }
Пример #4
0
 protected String getWithClause(PropertyPath path) {
   return translator.getWithClause(path.getFullPath());
 }
Пример #5
0
 protected JoinType getJoinType(
     OuterJoinLoadable persister,
     final PropertyPath path,
     int propertyNumber,
     AssociationType associationType,
     FetchMode metadataFetchMode,
     CascadeStyle metadataCascadeStyle,
     String lhsTable,
     String[] lhsColumns,
     final boolean nullable,
     final int currentDepth)
     throws MappingException {
   final JoinType resolvedJoinType;
   if (translator.isJoin(path.getFullPath())) {
     resolvedJoinType = translator.getJoinType(path.getFullPath());
   } else {
     if (translator.hasProjection()) {
       resolvedJoinType = JoinType.NONE;
     } else {
       FetchMode fetchMode = translator.getRootCriteria().getFetchMode(path.getFullPath());
       if (isDefaultFetchMode(fetchMode)) {
         if (persister != null) {
           if (isJoinFetchEnabledByProfile(persister, path, propertyNumber)) {
             if (isDuplicateAssociation(lhsTable, lhsColumns, associationType)) {
               resolvedJoinType = JoinType.NONE;
             } else if (isTooDeep(currentDepth)
                 || (associationType.isCollectionType() && isTooManyCollections())) {
               resolvedJoinType = JoinType.NONE;
             } else {
               resolvedJoinType = getJoinType(nullable, currentDepth);
             }
           } else {
             resolvedJoinType =
                 super.getJoinType(
                     persister,
                     path,
                     propertyNumber,
                     associationType,
                     metadataFetchMode,
                     metadataCascadeStyle,
                     lhsTable,
                     lhsColumns,
                     nullable,
                     currentDepth);
           }
         } else {
           resolvedJoinType =
               super.getJoinType(
                   associationType,
                   metadataFetchMode,
                   path,
                   lhsTable,
                   lhsColumns,
                   nullable,
                   currentDepth,
                   metadataCascadeStyle);
         }
       } else {
         if (fetchMode == FetchMode.JOIN) {
           isDuplicateAssociation(
               lhsTable, lhsColumns, associationType); // deliberately ignore return value!
           resolvedJoinType = getJoinType(nullable, currentDepth);
         } else {
           resolvedJoinType = JoinType.NONE;
         }
       }
     }
   }
   return resolvedJoinType;
 }