How to use

CollectionAliases

in

org.hibernate.loader

@Override
@SuppressWarnings("unchecked")
public Object readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)
throws HibernateException, SQLException {
  final Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
  final int index = (Integer) persister.readIndex( rs, descriptor.getSuffixedIndexAliases(), getSession() );
  for ( int i = tempList.size(); i<=index; i++) {
    tempList.add( i, null );
  }
  tempList.set( index, element );
  return element;
}

printWriter.println(
    TreePrinterHelper.INSTANCE.generateNodePrefix( depth+3 )
        + "alias suffix - " + collectionReferenceAliases.getCollectionColumnAliases().getSuffix()
);
printWriter.println(
    TreePrinterHelper.INSTANCE.generateNodePrefix( depth+3 )
        + "suffixed key columns - "
        + String.join( ", ", collectionReferenceAliases.getCollectionColumnAliases().getSuffixedKeyAliases() )
);
final EntityReferenceAliases elementAliases = collectionReferenceAliases.getEntityElementAliases();

@Override
public Object readFrom(
    ResultSet rs,
    CollectionPersister persister,
    CollectionAliases descriptor,
    Object owner) throws HibernateException, SQLException {
  final Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
  final Object old = identifiers.put(
    values.size(),
    persister.readIdentifier( rs, descriptor.getSuffixedIdentifierAlias(), getSession() )
  );
  if ( old == null ) {
    //maintain correct duplication if loaded in a cartesian product
    values.add( element );
  }
  return element;
}

@Override
@SuppressWarnings("unchecked")
public Object readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)
    throws HibernateException, SQLException {
  // note that if we load this collection from a cartesian product
  // the multiplicity would be broken ... so use an idbag instead
  final Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() ) ;
  if ( element != null ) {
    bag.add( element );
  }
  return element;
}

private void preLoadBatchFetchingQueue(SharedSessionContractImplementor session, TupleAsMapResultSet resultset) {
  // Logic to eliminate the n+1 issue in collection loading when batch fetching is enabled.
  //
  // Walk the resultset to hydrate the collection elements.
  // Hydrating will add associated entities to the batch fetching queue without loading them.
  // The next resultset walking will effectively load these associated entities
  // but with the help of the properly loaded batch fetching queue.
  // Without this double phase, each element is individually loaded leading to n+1
  // because the batch fetching queue does not contain the "next" elements.
  try {
    while ( resultset.next() ) {
      // Call hydrate on the collection element itself
      // This is too much work as we are only interested in ToOne hydration
      // But ToOne can be contained in ComponentType
      // TODO: only call this hydration phase if we know that the collection contains directly or indirectly ToOnes
      Tuple tuple = resultset.unwrap( TupleAsMapResultSet.class ).getTuple();
      collectionPersisters[0].getElementGridType().hydrate( tuple, collectionAliases[0].getSuffixedElementAliases(), session, null );
      // a key might exist and might be an entity (not currently supported though in OGM)
      if ( collectionPersisters[0].getKeyColumnNames().length > 0 ) {
        collectionPersisters[0].getKeyGridType()
            .hydrate( tuple, collectionAliases[0].getSuffixedKeyAliases(), session, null );
      }
    }
    // reset resultset for main loop
    resultset.beforeFirst();
  }
  catch (SQLException e) {
    //never happens this is not a regular ResultSet
  }
}

    descriptor.getSuffixedKeyAliases(),
    session
);

@Override
protected void applyRootReturnSelectFragments(SelectStatementBuilder selectStatementBuilder) {
  selectStatementBuilder.appendSelectClauseFragment(
      getQueryableCollection().selectFragment(
          null,
          null,
          //getCollectionReferenceAliases().getCollectionTableAlias(),
          getElementEntityReferenceAliases().getTableAlias(),
          getElementEntityReferenceAliases().getColumnAliases().getSuffix(),
          getCollectionReferenceAliases().getCollectionColumnAliases().getSuffix(),
          true
      )
  );
  super.applyRootReturnSelectFragments( selectStatementBuilder );
}

@Override
@SuppressWarnings("unchecked")
public Object readFrom(
    ResultSet rs,
    CollectionPersister persister,
    CollectionAliases descriptor,
    Object owner) throws HibernateException, SQLException {
  final Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
  if ( element != null ) {
    tempList.add( element );
  }
  return element;
}

final Serializable collectionRowKey = (Serializable) collectionReference.getCollectionPersister().readKey(
    resultSet,
    aliases.getCollectionColumnAliases().getSuffixedKeyAliases(),
    context.getSession()
);

@Override
protected void applyRootReturnSelectFragments(SelectStatementBuilder selectStatementBuilder) {
  selectStatementBuilder.appendSelectClauseFragment(
    getQueryableCollection().selectFragment(
        getCollectionReferenceAliases().getCollectionTableAlias(),
        getCollectionReferenceAliases().getCollectionColumnAliases().getSuffix()
    )
  );
  if ( getQueryableCollection().isManyToMany() ) {
    final OuterJoinLoadable elementPersister = (OuterJoinLoadable) getQueryableCollection().getElementPersister();
    selectStatementBuilder.appendSelectClauseFragment(
        elementPersister.selectFragment(
            getCollectionReferenceAliases().getElementTableAlias(),
            getCollectionReferenceAliases().getEntityElementAliases().getColumnAliases().getSuffix()
        )
    );
  }
  super.applyRootReturnSelectFragments( selectStatementBuilder );
}

@Override
@SuppressWarnings("unchecked")
public Object readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)
    throws HibernateException, SQLException {
  final Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() ) ;
  final int index = (Integer) persister.readIndex( rs, descriptor.getSuffixedIndexAliases(), getSession() );
  //pad with nulls from the current last element up to the new index
  for ( int i = list.size(); i<=index; i++) {
    list.add( i, null );
  }
  list.set( index, element );
  return element;
}

public Object readFrom(
    ResultSet rs,
    CollectionPersister persister,
    CollectionAliases descriptor,
    Object owner) throws HibernateException, SQLException {
  Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
  if (element!=null) tempList.add(element);
  return element;
}

public Object readFrom(
  ResultSet rs,
  CollectionPersister persister,
  CollectionAliases descriptor,
  Object owner)
  throws HibernateException, SQLException {
  Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
  Object old = identifiers.put(
    new Integer( values.size() ),
    persister.readIdentifier( rs, descriptor.getSuffixedIdentifierAlias(), getSession() )
  );
  if ( old==null ) values.add(element); //maintain correct duplication if loaded in a cartesian product
  return element;
}

final Serializable collectionRowKey = (Serializable) persister.readKey( rs, descriptor.getSuffixedKeyAliases(), session );

printWriter.println(
    TreePrinterHelper.INSTANCE.generateNodePrefix( depth + detailDepthOffset )
        + "alias suffix - " + collectionReferenceAliases.getCollectionColumnAliases().getSuffix()
);
printWriter.println(
    TreePrinterHelper.INSTANCE.generateNodePrefix( depth + detailDepthOffset )
        + "suffixed key columns - {"
        + String.join( ", ", collectionReferenceAliases.getCollectionColumnAliases().getSuffixedKeyAliases() )
        + "}"
);

    aliases.getCollectionColumnAliases().getSuffix(),
    true
queryableCollection.selectFragment(
    aliases.getElementTableAlias(),
    aliases.getCollectionColumnAliases().getSuffix()

@Override
@SuppressWarnings("unchecked")
public Object readFrom(
    ResultSet rs,
    CollectionPersister persister,
    CollectionAliases descriptor,
    Object owner) throws HibernateException, SQLException {
  final Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
  if ( element != null ) {
    final Object index = persister.readIndex( rs, descriptor.getSuffixedIndexAliases(), getSession() );
    if ( loadingEntries == null ) {
      loadingEntries = new ArrayList<>();
    }
    loadingEntries.add( new Object[] { index, element } );
  }
  return element;
}

public Object readFrom(
    ResultSet rs,
    CollectionPersister persister,
    CollectionAliases descriptor,
    Object owner) throws HibernateException, SQLException {
  Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
  if (element!=null) tempList.add(element);
  return element;
}

public Object readFrom(
  ResultSet rs,
  CollectionPersister persister,
  CollectionAliases descriptor,
  Object owner)
  throws HibernateException, SQLException {
  Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
  Object old = identifiers.put(
    values.size(),
    persister.readIdentifier( rs, descriptor.getSuffixedIdentifierAlias(), getSession() )
  );
  if ( old==null ) values.add(element); //maintain correct duplication if loaded in a cartesian product
  return element;
}

  descriptor.getSuffixedKeyAliases(), 
  session 
);