java类javax.persistence.metamodel.SetAttribute的实例源码

@SuppressWarnings("unchecked")
@Nonnull
public static <T, U> Join<T, U> join(
        @Nonnull final From<?, T> from, @Nonnull final PluralAttribute<? super T, ?, U> attribute) {

    Objects.requireNonNull(from, "from is null");
    Objects.requireNonNull(attribute, "attribute is null");

    if (attribute instanceof CollectionAttribute) {
        return from.join((CollectionAttribute<T, U>) attribute);
    }
    if (attribute instanceof SetAttribute) {
        return from.join((SetAttribute<T, U>) attribute);
    }
    if (attribute instanceof ListAttribute) {
        return from.join((ListAttribute<T, U>) attribute);
    }
    if (attribute instanceof MapAttribute) {
        return from.join((MapAttribute<T, ?, U>) attribute);
    }

    // Should never end up here.
    throw new IllegalArgumentException();
}

@SuppressWarnings("unchecked")
protected SetJoin<UserEntity, ExtensionFieldValueEntity> createOrGetJoin(String alias, Root<UserEntity> root,
                                                                         SetAttribute<UserEntity, ExtensionFieldValueEntity> attribute) {

    for (Join<UserEntity, ?> currentJoin : root.getJoins()) {
        if (currentJoin.getAlias() == null) {
            // if alias is null, it is not an alias for an extension join, so we ignore it
            continue;
        }

        if (currentJoin.getAlias().equals(alias)) {
            return (SetJoin<UserEntity, ExtensionFieldValueEntity>) currentJoin;
        }
    }

    final SetJoin<UserEntity, ExtensionFieldValueEntity> join = root.join(attribute, JoinType.LEFT);

    join.alias(alias);

    return join;
}

@SuppressWarnings("unchecked")
protected SetJoin<UserEntity, ExtensionFieldValueEntity> createOrGetJoin(String alias, Root<UserEntity> root,
                                                                         SetAttribute<UserEntity, ExtensionFieldValueEntity> attribute) {

    for (Join<UserEntity, ?> currentJoin : root.getJoins()) {
        if (currentJoin.getAlias() == null) {
            // if alias is null, it is not an alias for an extension join, so we ignore it
            continue;
        }

        if (currentJoin.getAlias().equals(alias)) {
            return (SetJoin<UserEntity, ExtensionFieldValueEntity>) currentJoin;
        }
    }

    final SetJoin<UserEntity, ExtensionFieldValueEntity> join = root.join(attribute, JoinType.LEFT);

    join.alias(alias);

    return join;
}

@SuppressWarnings("unchecked")
private <V> Expression<?> castGet(final Attribute<K, V> attribute, Join<E, K> join)
{
    if (attribute instanceof SingularAttribute)
    {
        return join.get((SingularAttribute<K, V>) attribute);
    }
    else if (attribute instanceof ListAttribute)
    {
        return join.get((ListAttribute<K, V>) attribute);
    }
    else if (attribute instanceof SetAttribute)
    {
        return join.get((SetAttribute<K, V>) attribute);
    }
    else
    {
        return null;
    }
}

/**
 * @return last possibly used alias
 */
private int copyJoins(From<?, ?> from, From<?, ?> to, int counter) {
    for (Join<?, ?> join : sort(comparator, from.getJoins())) {
        Attribute<?, ?> attr = join.getAttribute();
        // Hibern fails with String-bases api; Join.join(String, JoinType)
        @SuppressWarnings({ "rawtypes", "unchecked" })
        Join<Object, Object> j = attr instanceof SingularAttribute ? to.join((SingularAttribute) join.getAttribute(), join.getJoinType()) :
            attr instanceof CollectionAttribute ? to.join((CollectionAttribute) join.getAttribute(), join.getJoinType()) :
            attr instanceof SetAttribute ? to.join((SetAttribute) join.getAttribute(), join.getJoinType()) :
            attr instanceof ListAttribute ? to.join((ListAttribute) join.getAttribute(), join.getJoinType()) :
            attr instanceof MapAttribute ? to.join((MapAttribute) join.getAttribute(), join.getJoinType()) :
            to.join((CollectionAttribute) join.getAttribute(), join.getJoinType());
        copyAlias(join, j, ++counter);
        counter = copyJoins(join, j, ++counter);
    }
    copyFetches(from, to);
    return counter;
}

@Nonnull
public static <T, U> Specification<T> inCollection(
        @Nonnull final SetAttribute<? super T, U> setAttribute, @Nullable final Collection<U> values) {

    Objects.requireNonNull(setAttribute, "setAttribute must not be null");

    return (root, query, cb) -> JpaPreds.inCollection(cb, root.join(setAttribute), values);
}

@Override
    public <Y> JpaSetJoin<X, Y> join(SetAttribute<? super X, Y> set, JoinType jt) {
//      if ( !canBeJoinSource() ) {
//          throw illegalJoin();
//      }
//
//      final SetJoin<X, Y> join = constructJoin( set, jt );
//      joinScope.addJoin( join );
//      return join;

        throw new NotYetImplementedException(  );
    }

@Override
@SuppressWarnings({"unchecked"})
public <X, Y> JpaAttributeJoin<X, Y> join(String attributeName, JoinType jt) {
    if ( !canBeJoinSource() ) {
        throw illegalJoin();
    }

    if ( jt.equals( JoinType.RIGHT ) ) {
        throw new UnsupportedOperationException( "RIGHT JOIN not supported" );
    }

    final Attribute<X, ?> attribute = (Attribute<X, ?>) locateAttribute( attributeName );
    if ( attribute.isCollection() ) {
        final PluralAttribute pluralAttribute = (PluralAttribute) attribute;
        if ( PluralAttribute.CollectionType.COLLECTION.equals( pluralAttribute.getCollectionType() ) ) {
            return (JpaAttributeJoin<X, Y>) join( (CollectionAttribute) attribute, jt );
        }
        else if ( PluralAttribute.CollectionType.LIST.equals( pluralAttribute.getCollectionType() ) ) {
            return (JpaAttributeJoin<X, Y>) join( (ListAttribute) attribute, jt );
        }
        else if ( PluralAttribute.CollectionType.SET.equals( pluralAttribute.getCollectionType() ) ) {
            return (JpaAttributeJoin<X, Y>) join( (SetAttribute) attribute, jt );
        }
        else {
            return (JpaAttributeJoin<X, Y>) join( (MapAttribute) attribute, jt );
        }
    }
    else {
        return (JpaAttributeJoin<X, Y>) join( (SingularAttribute) attribute, jt );
    }
}

@Override
@SuppressWarnings({"unchecked"})
public <X, Y> JpaSetJoin<X, Y> joinSet(String attributeName, JoinType jt) {
    final Attribute<X, ?> attribute = (Attribute<X, ?>) locateAttribute( attributeName );
    if ( !attribute.isCollection() ) {
        throw new IllegalArgumentException( "Requested attribute was not a set" );
    }

    final PluralAttribute pluralAttribute = (PluralAttribute) attribute;
    if ( !PluralAttribute.CollectionType.SET.equals( pluralAttribute.getCollectionType() ) ) {
        throw new IllegalArgumentException( "Requested attribute was not a set" );
    }

    return (JpaSetJoin<X, Y>) join( (SetAttribute) attribute, jt );
}

long countUsersWithMetaData(T entity, SetAttribute<User, T> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Long> query = cb.createQuery(Long.class);
    Root<User> root = query.from(User.class);
    Join<User, T> join = root.join(attribute);
    query.where(join.in(entity));
    query.select(cb.countDistinct(root));
    return em.createQuery(query).getSingleResult();
}

long countQOWithMetaData(T entity, SetAttribute<QMBaseIndicator, QModelTagData> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Long> query = cb.createQuery(Long.class);
    Root<QMQualityObjective> root = query.from(QMQualityObjective.class);
    Join<QMQualityObjective, QModelTagData> join = root.join(attribute);
    query.where(join.get(QModelTagData_.tagId).in(entity.getId()));
    query.select(cb.countDistinct(root));
    return em.createQuery(query).getSingleResult();
}

long countQIWithMetaData(T entity, SetAttribute<QMBaseIndicator, QModelTagData> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Long> query = cb.createQuery(Long.class);
    Root<QMQualityIndicator> root = query.from(QMQualityIndicator.class);
    Join<QMQualityIndicator, QModelTagData> join = root.join(attribute);
    query.where(join.get(QModelTagData_.tagId).in(entity.getId()));
    query.select(cb.countDistinct(root));
    return em.createQuery(query).getSingleResult();
}

long countQMetricWithMetaData(T entity, SetAttribute<QMBaseIndicator, QModelTagData> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Long> query = cb.createQuery(Long.class);
    Root<QMMetric> root = query.from(QMMetric.class);
    Join<QMMetric, QModelTagData> join = root.join(attribute);
    query.where(join.get(QModelTagData_.tagId).in(entity.getId()));
    query.select(cb.countDistinct(root));
    return em.createQuery(query).getSingleResult();
}

long countprojectsWithMetaData(T entity, SetAttribute<Project, T> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Long> query = cb.createQuery(Long.class);
    Root<Project> root = query.from(Project.class);
    Join<Project, T> join = root.join(attribute);
    query.where(join.in(entity));
    query.select(cb.countDistinct(root));
    return em.createQuery(query).getSingleResult();
}

List<User> getUsersWithMetaData(T entity, SetAttribute<User, T> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<User> query = cb.createQuery(User.class);
    Root<User> root = query.from(User.class);
    Join<User, T> join = root.join(attribute);
    query.where(join.in(entity));
    return em.createQuery(query).getResultList();
}

List<Project> getProjectsWithMetaData(T entity, SetAttribute<Project, T> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Project> query = cb.createQuery(Project.class);
    Root<Project> root = query.from(Project.class);
    Join<Project, T> join = root.join(attribute);
    query.where(join.in(entity));
    return em.createQuery(query).getResultList();
}

private List<QMQualityObjective> getQOWithMetaData(T entity, SetAttribute<QMBaseIndicator, QModelTagData> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<QMQualityObjective> query = cb.createQuery(QMQualityObjective.class);
    Root<QMQualityObjective> root = query.from(QMQualityObjective.class);
    Join<QMQualityObjective, QModelTagData> join = root.join(attribute);
    query.where(join.get(QModelTagData_.tagId).in(entity.getId()));
    return em.createQuery(query).getResultList();
}

private List<QMQualityIndicator> getQIWithMetaData(T entity, SetAttribute<QMBaseIndicator, QModelTagData> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<QMQualityIndicator> query = cb.createQuery(QMQualityIndicator.class);
    Root<QMQualityIndicator> root = query.from(QMQualityIndicator.class);
    Join<QMQualityIndicator, QModelTagData> join = root.join(attribute);
    query.where(join.get(QModelTagData_.tagId).in(entity.getId()));
    return em.createQuery(query).getResultList();
}

private List<QMMetric> getQMetricWithMetaData(T entity, SetAttribute<QMBaseIndicator, QModelTagData> attribute) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<QMMetric> query = cb.createQuery(QMMetric.class);
    Root<QMMetric> root = query.from(QMMetric.class);
    Join<QMMetric, QModelTagData> join = root.join(attribute);
    query.where(join.get(QModelTagData_.tagId).in(entity.getId()));
    return em.createQuery(query).getResultList();
}

public <T extends CustomField<?>> T doBinding(String fieldLabel, SetAttribute<?, ?> field, T customField)
{

    doBinding(group, field.getName(), customField);
    this.fieldList.add(customField);
    form.addComponent(customField);
    return customField;

}

/**
 * the set in the parent table that holds the set of children
 * 
 * @param field
 * @return
 */
public TwinColSelectBuilder<L> setField(SetAttribute<E, L> field)
{
    this.field = field.getName();
    listClazz = field.getBindableJavaType();
    return this;
}

public <J, V> Condition<E> eq(final JoinBuilder<E, J> join, final SetAttribute<J, V> field, final V value)
{
    return new AbstractCondition<E>()
    {

        @Override
        public Predicate getPredicates()
        {
            return builder.equal(getJoin(join).get(field), value);
        }
    };
}

public <J, V> Condition<E> equal(final SetAttribute<? super E, J> joinAttribute, final JoinType joinType,
        final SingularAttribute<J, V> field, final V value)
{
    return new AbstractCondition<E>()
    {

        @Override
        public Predicate getPredicates()
        {
            Join<E, J> join = getJoin(joinAttribute, joinType);
            return builder.equal(join.get(field), value);
        }
    };
}

public <L> Condition<E> equal(final SetAttribute<E, L> field, final L value)
{

    return new AbstractCondition<E>()
    {

        @Override
        public Predicate getPredicates()
        {
            return builder.equal(root.get(field), value);
        }
    };
}

public <J, V extends Comparable<? super V>> Condition<E> greaterThanOrEqualTo(
        final SetAttribute<? super E, J> joinAttribute, final JoinType joinType,
        final SingularAttribute<J, V> field, final V value)
{
    return new AbstractCondition<E>()
    {

        @Override
        public Predicate getPredicates()
        {
            Join<E, J> join = getJoin(joinAttribute, joinType);
            return builder.greaterThanOrEqualTo(join.get(field), value);
        }
    };
}

public <V> Condition<E> in(final SetAttribute<E, V> attribute, final Collection<V> values)
{
    return new AbstractCondition<E>()
    {

        @Override
        public Predicate getPredicates()
        {
            return root.get(attribute).in(values);
        }
    };
}

public <V> Condition<E> in(final SetAttribute<E, V> agents, final V agent)
{
    return new AbstractCondition<E>()
    {

        @Override
        public Predicate getPredicates()
        {
            return root.get(agents).in(agent);
        }
    };
}

public <J, V extends Comparable<? super V>> Condition<E> lessThanOrEqualTo(
        final SetAttribute<? super E, J> joinAttribute, final JoinType joinType,
        final SingularAttribute<J, V> field, final V value)
{
    return new AbstractCondition<E>()
    {

        @Override
        public Predicate getPredicates()
        {
            Join<E, J> join = getJoin(joinAttribute, joinType);
            return builder.lessThanOrEqualTo(join.get(field), value);
        }
    };
}

@SuppressWarnings(
{ "unchecked", "rawtypes" })
private <T> JoinBuilder<E, T> join(final SetAttribute<K, T> attribute, final JoinType type, final boolean fetch)
{
    final JoinBuilder<E, T> jb = new JoinBuilder<E, T>();
    jb.joins.addAll(joins);
    jb.joins.add(new JoinMetaDataSet(attribute, type, fetch));

    return jb;
}

/**
 * join on parent.child = child
 * 
 * @param parentAttrib
 * @return
 */
public AbstractCondition<E> joinParentQueryOnParentAttrib(final SetAttribute<P, E> parentAttrib)
{
    return new AbstractCondition<E>()
    {

        @Override
        public Predicate getPredicates()
        {
            return builder.equal(parentRoot.get(parentAttrib), root);

        }
    };
}