Set set = new LinkedHashSet();
set.addAll(query.list());   
return set;

        Criteria criteria = getSession().createCriteria(Person.class);
        criteria.add(Restrictions.eq(COMPOSITE_ID + "." + ATTRIBUTE_PERSON_ID, inPersonId));       
        criteria.setFetchMode("addresses", FetchMode.JOIN);
        criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
        return criteria.list();

public class CriteriaDao extends HibernateDaoSupport {

    public int getCount(DetachedCriteria criteria) {
        return (Integer) getHibernateTemplate().findByCriteria(createCountProjection(criteria)).get(0);
    }

    /**
     * This implementation do the real pagination of entities, and is also aware of duplicate parent entities problem.
     * It heavy relies on criteria projection api to avoid the duplicate problem, yet accomplish the true pagination.
     */
    public <T> List<T> getAll(DetachedCriteria criteria, SortAndPagingParams params) {
        DetachedCriteria idProjection = createIdProjectionPreservingSort(criteria, params);
        List<Long> idList = getHibernateTemplate().findByCriteria(idProjection, params.getFirst(), params.getCount());
        DetachedCriteria idListCriteria = createGetByIdListCriteria(criteria, params, idList);
        List<T> rezultWithDuplicates = getHibernateTemplate().findByCriteria(idListCriteria);
        List<T> rezult = distinctList(rezultWithDuplicates);
        return rezult;
    }

    protected static DetachedCriteria createSortedCriteria(DetachedCriteria criteria, SortAndPagingParams params) {
        DetachedCriteria rez = copy(criteria);
        if (params.getSortProperty() != null) {
            rez.addOrder(params.isSortAsc() ? Order.asc(params.getSortProperty()) :
                    Order.desc(params.getSortProperty()));
        }
        return rez;
    }

    protected static DetachedCriteria createCountProjection(DetachedCriteria criteria) {
        DetachedCriteria rez = copy(criteria);
        rez.setProjection(Projections.countDistinct("id"));
        return rez;
    }

    /**
     * List the given criteria and return only distinct values.
     *
     * @see <a href="https://forum.hibernate.org/viewtopic.php?t=955186">Duplicate Parent record when joined with
     *      one-to-many</a>
     *      <p/>
     * @see <a href="https://www.hibernate.org/117.241.html">fetch produces duplicate entries</a>
     */
    @SuppressWarnings({"unchecked"})
    protected static <T> List<T> distinctList(List<T> initialList) {
        return new ArrayList<T>(new LinkedHashSet<T>(initialList));
    }

    /**
     * Copy (deep clone) the provided criteria using serialization.
     *
     * @see <a href="https://forum.hibernate.org/viewtopic.php?t=939781">Cloning criteria using serialization</a>
     */
    protected static DetachedCriteria copy(DetachedCriteria criteria) {
        try {
            ByteArrayOutputStream baostream = new ByteArrayOutputStream();
            ObjectOutputStream oostream = new ObjectOutputStream(baostream);
            oostream.writeObject(criteria);
            oostream.flush();
            oostream.close();
            ByteArrayInputStream baistream = new ByteArrayInputStream(baostream.toByteArray());
            ObjectInputStream oistream = new ObjectInputStream(baistream);
            DetachedCriteria copy = (DetachedCriteria) oistream.readObject();
            oistream.close();
            return copy;
        } catch (Throwable t) {
            throw new HibernateException(t);
        }
    }

    protected static DetachedCriteria createIdProjectionPreservingSort(DetachedCriteria criteria, SortAndPagingParams params) {
        DetachedCriteria rez = createSortedCriteria(criteria, params);
        rez.setProjection(Projections.distinct(Projections.id()));
        return rez;
    }

    protected static DetachedCriteria createGetByIdListCriteria(DetachedCriteria criteria, SortAndPagingParams params,
                                                                List<Long> idList) {
        DetachedCriteria rez = createSortedCriteria(criteria, params);
        rez.add(Restrictions.in("id", idList));
        return rez;
    }
}

/**
* Data passed from data provider to dao layer, containing information about sort and paging.
*
* @author Denis Bogdanas
*/
public class SortAndPagingParams {
    private String sortProperty;
    private boolean sortAsc;
    private int first;
    private int count;

    public SortAndPagingParams(String sortProperty, boolean sortAsc, int first, int count) {
        this.sortProperty = sortProperty;
        this.sortAsc = sortAsc;
        this.first = first;
        this.count = count;
    }

    public String getSortProperty() {
        return sortProperty;
    }

    public boolean isSortAsc() {
        return sortAsc;
    }

    public int getFirst() {
        return first;
    }

    public int getCount() {
        return count;
    }
}

class Parent {
  private List<Child> children;
}
class Child {
  private String name;
}

select distinct p, (select min(c.name) from p.children c) from Parent p
[any joins]
where [anything]
order by 2