private FromElement createFromElement(EntityPersister entityPersister) {
   Joinable joinable = (Joinable) entityPersister;
   String text = joinable.getTableName();
   AST ast = createFromElement(text);
   FromElement element = (FromElement) ast;
   return element;
 }
  @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 void addManyToManyJoin(JoinFragment outerjoin, QueryableCollection collection)
     throws MappingException {
   String manyToManyFilter = collection.getManyToManyFilterFragment(rhsAlias, enabledFilters);
   String condition =
       "".equals(manyToManyFilter)
           ? on
           : "".equals(on) ? manyToManyFilter : on + " and " + manyToManyFilter;
   outerjoin.addJoin(
       joinable.getTableName(), rhsAlias, lhsColumns, rhsColumns, joinType, condition);
   outerjoin.addJoins(
       joinable.fromJoinFragment(rhsAlias, false, true),
       joinable.whereJoinFragment(rhsAlias, false, true));
 }
  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;
  }
 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) : "";
 }
Example #6
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);
      }
    }
  }
 public boolean isManyToManyWith(OuterJoinableAssociation other) {
   if (joinable.isCollection()) {
     QueryableCollection persister = (QueryableCollection) joinable;
     if (persister.isManyToMany()) {
       return persister.getElementType() == other.getJoinableType();
     }
   }
   return false;
 }
  private String manyToManySelectFragment(
      Joinable rhs, String rhsAlias, String lhsAlias, String collectionSuffix) {
    SelectFragment frag = generateSelectFragment(lhsAlias, collectionSuffix);

    String[] elementColumnNames = rhs.getKeyColumnNames();
    frag.addColumns(rhsAlias, elementColumnNames, elementColumnAliases);
    appendIndexColumns(frag, lhsAlias);
    appendIdentifierColumns(frag, lhsAlias);

    return frag.toFragmentString().substring(2); // strip leading ','
  }
Example #9
0
  /** Generate a select list of columns containing all properties of the entity classes */
  protected final String selectString(List associations) throws MappingException {

    if (associations.size() == 0) {
      return "";
    } else {
      StringBuilder buf = new StringBuilder(associations.size() * 100);
      int entityAliasCount = 0;
      int collectionAliasCount = 0;
      for (int i = 0; i < associations.size(); i++) {
        OuterJoinableAssociation join = (OuterJoinableAssociation) associations.get(i);
        OuterJoinableAssociation next =
            (i == associations.size() - 1)
                ? null
                : (OuterJoinableAssociation) associations.get(i + 1);
        final Joinable joinable = join.getJoinable();
        final String entitySuffix =
            (suffixes == null || entityAliasCount >= suffixes.length)
                ? null
                : suffixes[entityAliasCount];
        final String collectionSuffix =
            (collectionSuffixes == null || collectionAliasCount >= collectionSuffixes.length)
                ? null
                : collectionSuffixes[collectionAliasCount];
        final String selectFragment =
            joinable.selectFragment(
                next == null ? null : next.getJoinable(),
                next == null ? null : next.getRHSAlias(),
                join.getRHSAlias(),
                entitySuffix,
                collectionSuffix,
                join.getJoinType() == JoinType.LEFT_OUTER_JOIN);
        if (selectFragment.trim().length() > 0) {
          buf.append(", ").append(selectFragment);
        }
        if (joinable.consumesEntityAlias()) entityAliasCount++;
        if (joinable.consumesCollectionAlias() && join.getJoinType() == JoinType.LEFT_OUTER_JOIN)
          collectionAliasCount++;
      }
      return buf.toString();
    }
  }
 public void addJoins(JoinFragment outerjoin) throws MappingException {
   outerjoin.addJoin(joinable.getTableName(), rhsAlias, lhsColumns, rhsColumns, joinType, on);
   outerjoin.addJoins(
       joinable.fromJoinFragment(rhsAlias, false, true),
       joinable.whereJoinFragment(rhsAlias, false, true));
 }
Example #11
0
 protected String generateTableAlias(
     final int n, final PropertyPath path, final Joinable joinable) {
   return StringHelper.generateAlias(joinable.getName(), n);
 }