@Override
  public AssociationKey getAssociationKey() {
    final AssociationType type = getType();

    if (type.isAnyType()) {
      return new AssociationKey(
          JoinHelper.getLHSTableName(type, attributeNumber(), (OuterJoinLoadable) getSource()),
          JoinHelper.getLHSColumnNames(
              type, attributeNumber(), 0, (OuterJoinLoadable) getSource(), sessionFactory()));
    }

    final Joinable joinable = type.getAssociatedJoinable(sessionFactory());

    if (type.getForeignKeyDirection() == ForeignKeyDirection.FOREIGN_KEY_FROM_PARENT) {
      final String lhsTableName;
      final String[] lhsColumnNames;

      if (joinable.isCollection()) {
        final QueryableCollection collectionPersister = (QueryableCollection) joinable;
        lhsTableName = collectionPersister.getTableName();
        lhsColumnNames = collectionPersister.getElementColumnNames();
      } else {
        final OuterJoinLoadable entityPersister = (OuterJoinLoadable) source();
        lhsTableName = getLHSTableName(type, attributeNumber(), entityPersister);
        lhsColumnNames =
            getLHSColumnNames(type, attributeNumber(), entityPersister, sessionFactory());
      }
      return new AssociationKey(lhsTableName, lhsColumnNames);
    } else {
      return new AssociationKey(joinable.getTableName(), getRHSColumnNames(type, sessionFactory()));
    }
  }
 public OuterJoinableAssociation(
     PropertyPath propertyPath,
     AssociationType joinableType,
     String lhsAlias,
     String[] lhsColumns,
     String rhsAlias,
     JoinType joinType,
     String withClause,
     boolean hasRestriction,
     SessionFactoryImplementor factory,
     Map enabledFilters)
     throws MappingException {
   this.propertyPath = propertyPath;
   this.joinableType = joinableType;
   this.lhsAlias = lhsAlias;
   this.lhsColumns = lhsColumns;
   this.rhsAlias = rhsAlias;
   this.joinType = joinType;
   this.joinable = joinableType.getAssociatedJoinable(factory);
   this.rhsColumns = JoinHelper.getRHSColumnNames(joinableType, factory);
   this.on =
       joinableType.getOnCondition(rhsAlias, factory, enabledFilters)
           + (withClause == null || withClause.trim().length() == 0
               ? ""
               : " and ( " + withClause + " )");
   this.hasRestriction = hasRestriction;
   this.enabledFilters = enabledFilters; // needed later for many-to-many/filter application
 }
Ejemplo n.º 3
0
 /** Used to detect circularities in the joined graph, note that this method is side-effecty */
 protected boolean isDuplicateAssociation(
     final String lhsTable, final String[] lhsColumnNames, final AssociationType type) {
   final String foreignKeyTable;
   final String[] foreignKeyColumns;
   if (type.getForeignKeyDirection() == ForeignKeyDirection.FOREIGN_KEY_FROM_PARENT) {
     foreignKeyTable = lhsTable;
     foreignKeyColumns = lhsColumnNames;
   } else {
     foreignKeyTable = type.getAssociatedJoinable(getFactory()).getTableName();
     foreignKeyColumns = JoinHelper.getRHSColumnNames(type, getFactory());
   }
   return isDuplicateAssociation(foreignKeyTable, foreignKeyColumns);
 }
Ejemplo n.º 4
0
  private CriteriaInfoProvider getPathInfo(String path) {
    StringTokenizer tokens = new StringTokenizer(path, ".");
    String componentPath = "";

    // start with the 'rootProvider'
    CriteriaInfoProvider provider = nameCriteriaInfoMap.get(rootEntityName);

    while (tokens.hasMoreTokens()) {
      componentPath += tokens.nextToken();
      Type type = provider.getType(componentPath);
      if (type.isAssociationType()) {
        // CollectionTypes are always also AssociationTypes - but there's not always an associated
        // entity...
        AssociationType atype = (AssociationType) type;
        CollectionType ctype = type.isCollectionType() ? (CollectionType) type : null;
        Type elementType = (ctype != null) ? ctype.getElementType(sessionFactory) : null;
        // is the association a collection of components or value-types? (i.e a colloction of valued
        // types?)
        if (ctype != null && elementType.isComponentType()) {
          provider =
              new ComponentCollectionCriteriaInfoProvider(
                  helper.getCollectionPersister(ctype.getRole()));
        } else if (ctype != null && !elementType.isEntityType()) {
          provider = new ScalarCollectionCriteriaInfoProvider(helper, ctype.getRole());
        } else {
          provider =
              new EntityCriteriaInfoProvider(
                  (Queryable)
                      sessionFactory.getEntityPersister(
                          atype.getAssociatedEntityName(sessionFactory)));
        }

        componentPath = "";
      } else if (type.isComponentType()) {
        if (!tokens.hasMoreTokens()) {
          throw new QueryException(
              "Criteria objects cannot be created directly on components.  Create a criteria on owning entity and use a dotted property to access component property: "
                  + path);
        } else {
          componentPath += '.';
        }
      } else {
        throw new QueryException("not an association: " + componentPath);
      }
    }

    return provider;
  }
 private boolean isOneToOne() {
   if (joinableType.isEntityType()) {
     EntityType etype = (EntityType) joinableType;
     return etype.isOneToOne() /*&& etype.isReferenceToPrimaryKey()*/;
   } else {
     return false;
   }
 }
 public String selectFragment(
     Joinable rhs,
     String rhsAlias,
     String lhsAlias,
     String entitySuffix,
     String collectionSuffix,
     boolean includeCollectionColumns) {
   // we need to determine the best way to know that two joinables
   // represent a single many-to-many...
   if (rhs != null && isManyToMany() && !rhs.isCollection()) {
     AssociationType elementType = ((AssociationType) getElementType());
     if (rhs.equals(elementType.getAssociatedJoinable(getFactory()))) {
       return manyToManySelectFragment(rhs, rhsAlias, lhsAlias, collectionSuffix);
     }
   }
   return includeCollectionColumns ? selectFragment(lhsAlias, collectionSuffix) : "";
 }
  protected void initPropertyPaths(
      final String path,
      final Type type,
      String[] columns,
      final String[] formulaTemplates,
      final Mapping factory)
      throws MappingException {

    if (columns.length != type.getColumnSpan(factory)) {
      throw new MappingException("broken column mapping for: " + path + " of: " + getEntityName());
    }

    if (type.isAssociationType()) {
      AssociationType actype = (AssociationType) type;
      if (actype.useLHSPrimaryKey()) {
        columns = getIdentifierColumnNames();
      } else {
        String foreignKeyProperty = actype.getLHSPropertyName();
        if (foreignKeyProperty != null && !path.equals(foreignKeyProperty)) {
          // TODO: this requires that the collection is defined after the
          //      referenced property in the mapping file (ok?)
          columns = (String[]) columnsByPropertyPath.get(foreignKeyProperty);
          if (columns == null) return; // get em on the second pass!
        }
      }
    }

    if (path != null) addPropertyPath(path, type, columns, formulaTemplates);

    if (type.isComponentType()) {
      AbstractComponentType actype = (AbstractComponentType) type;
      initComponentPropertyPaths(path, actype, columns, formulaTemplates, factory);
      if (actype.isEmbedded()) {
        initComponentPropertyPaths(
            path == null ? null : StringHelper.qualifier(path),
            actype,
            columns,
            formulaTemplates,
            factory);
      }
    } else if (type.isEntityType()) {
      initIdentifierPropertyPaths(path, (EntityType) type, columns, factory);
    }
  }
Ejemplo n.º 8
0
 /**
  * Does the mapping, and Hibernate default semantics, specify that this association should be
  * fetched by outer joining
  */
 protected boolean isJoinedFetchEnabledInMapping(FetchMode config, AssociationType type)
     throws MappingException {
   if (!type.isEntityType() && !type.isCollectionType()) {
     return false;
   } else {
     if (config == FetchMode.JOIN) return true;
     if (config == FetchMode.SELECT) return false;
     if (type.isEntityType()) {
       // TODO: look at the owning property and check that it
       //      isn't lazy (by instrumentation)
       EntityType entityType = (EntityType) type;
       EntityPersister persister =
           getFactory().getEntityPersister(entityType.getAssociatedEntityName());
       return !persister.hasProxy();
     } else {
       return false;
     }
   }
 }
 private String getPathEntityName(String path) {
   Queryable persister = (Queryable) sessionFactory.getEntityPersister(rootEntityName);
   StringTokenizer tokens = new StringTokenizer(path, ".");
   String componentPath = "";
   while (tokens.hasMoreTokens()) {
     componentPath += tokens.nextToken();
     Type type = persister.toType(componentPath);
     if (type.isAssociationType()) {
       AssociationType atype = (AssociationType) type;
       persister =
           (Queryable)
               sessionFactory.getEntityPersister(atype.getAssociatedEntityName(sessionFactory));
       componentPath = "";
     } else if (type.isComponentType()) {
       componentPath += '.';
     } else {
       throw new QueryException("not an association: " + componentPath);
     }
   }
   return persister.getEntityName();
 }
 protected void setRelatedClassType(
     GrailsHibernateDomainClassProperty prop, AssociationType assType, Type hibernateType) {
   try {
     String associatedEntity =
         assType.getAssociatedEntityName((SessionFactoryImplementor) getSessionFactory());
     ClassMetadata associatedMetaData = getSessionFactory().getClassMetadata(associatedEntity);
     prop.setRelatedClassType(associatedMetaData.getMappedClass(EntityMode.POJO));
   } catch (MappingException me) {
     // other side must be a value object
     if (hibernateType.isCollectionType()) {
       prop.setRelatedClassType(Collection.class);
     }
   }
 }
Ejemplo n.º 11
0
  /**
   * Add on association (one-to-one, many-to-one, or a collection) to a list of associations to be
   * fetched by outerjoin
   */
  private void addAssociationToJoinTree(
      final AssociationType type,
      final String[] aliasedLhsColumns,
      final String alias,
      final PropertyPath path,
      final int currentDepth,
      final JoinType joinType)
      throws MappingException {

    Joinable joinable = type.getAssociatedJoinable(getFactory());

    // important to generate alias based on size of association collection
    // *before* adding this join to that collection
    String subalias = generateTableAlias(associations.size() + 1, path, joinable);

    // NOTE : it should be fine to continue to pass only filters below
    // (instead of LoadQueryInfluencers) since "from that point on" we
    // only need to worry about restrictions (and not say adding more
    // joins)
    OuterJoinableAssociation assoc =
        new OuterJoinableAssociation(
            path,
            type,
            alias,
            aliasedLhsColumns,
            subalias,
            joinType,
            getWithClause(path),
            hasRestriction(path),
            getFactory(),
            loadQueryInfluencers.getEnabledFilters());
    assoc.validateJoin(path.getFullPath());
    associations.add(assoc);

    int nextDepth = currentDepth + 1;
    //		path = "";
    if (!joinable.isCollection()) {
      if (joinable instanceof OuterJoinLoadable) {
        walkEntityTree((OuterJoinLoadable) joinable, subalias, path, nextDepth);
      }
    } else {
      if (joinable instanceof QueryableCollection) {
        walkCollectionTree((QueryableCollection) joinable, subalias, path, nextDepth);
      }
    }
  }
Ejemplo n.º 12
0
 /**
  * Determine the appropriate associationType of join (if any) to use to fetch the given
  * association.
  *
  * @param associationType The association associationType.
  * @param config The metadata-defined fetch mode.
  * @param path The path to the association
  * @param lhsTable The owner table
  * @param lhsColumns The owner join columns
  * @param nullable Is the association nullable.
  * @param currentDepth Current join depth
  * @param cascadeStyle The metadata-defined cascade style.
  * @return type of join to use ({@link org.hibernate.sql.JoinType#INNER_JOIN}, {@link
  *     org.hibernate.sql.JoinType#LEFT_OUTER_JOIN}, or -1 to indicate no joining.
  * @throws MappingException ??
  */
 protected JoinType getJoinType(
     AssociationType associationType,
     FetchMode config,
     PropertyPath path,
     String lhsTable,
     String[] lhsColumns,
     boolean nullable,
     int currentDepth,
     CascadeStyle cascadeStyle)
     throws MappingException {
   if (!isJoinedFetchEnabled(associationType, config, cascadeStyle)) {
     return JoinType.NONE;
   }
   if (isTooDeep(currentDepth) || (associationType.isCollectionType() && isTooManyCollections())) {
     return JoinType.NONE;
   }
   if (isDuplicateAssociation(lhsTable, lhsColumns, associationType)) {
     return JoinType.NONE;
   }
   return getJoinType(nullable, currentDepth);
 }
// $Id: CascadeEntityJoinWalker.java,v 1.1 2005/07/26 05:51:47 oneovthafew Exp $
 public boolean isCollection() {
   return joinableType.isCollectionType();
 }
 public String getRHSUniqueKeyName() {
   return joinableType.getRHSUniqueKeyPropertyName();
 }
Ejemplo n.º 16
0
 /** Override on subclasses to enable or suppress joining of certain association types */
 protected boolean isJoinedFetchEnabled(
     AssociationType type, FetchMode config, CascadeStyle cascadeStyle) {
   return type.isEntityType() && isJoinedFetchEnabledInMapping(config, type);
 }
Ejemplo n.º 17
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;
 }
 @Override
 protected Class getClassForAssociationType(AssociationType type) {
   String otherSideEntityName =
       type.getAssociatedEntityName((SessionFactoryImplementor) sessionFactory);
   return sessionFactory.getClassMetadata(otherSideEntityName).getMappedClass(EntityMode.POJO);
 }