java类javax.persistence.criteria.Selection的实例源码

private <S> S aggregate(CriteriaBuilder builder, CriteriaQuery<S> query, Root<E> root, Specification<E> spec, List<Selection<?>> selectionList, LockModeType lockMode) {
    if (selectionList != null) {
        Predicate predicate = spec.toPredicate(root, query, builder);
        if (predicate != null) {
            query.where(predicate);
        }
        query.multiselect(selectionList);
        return (S) em.createQuery(query).setLockMode(lockMode).getSingleResult();
    }
    return null;
}

@Override
public T select(Object... selections) {
    if (!beforeMethodInvoke()) {
        return (T) this;
    }
    List<Selection<?>> list = new ArrayList<Selection<?>>(selections.length);
    for (Object selection : selections) {
        if (selection instanceof String) {
            parseSelectionStr(list, (String) selection);
        } else if (selection instanceof Selection) {
            list.add((Selection<?>) selection);
        }
    }
    select(list.toArray(new Selection<?>[list.size()]));
    return (T) this;
}

private void parseSelectionStr(List<Selection<?>> result, String selection) {
    String[] ps = selection.split("\\s*,\\s*");
    for (String p : ps) {
        String alias = p.trim();
        String[] pa = alias.split("\\s+[aA][sS]\\s+");
        if (pa.length > 1) {
            alias = pa[1];
        } else {
            pa = alias.split("\\s+");
            if (pa.length > 1) {
                alias = pa[1];
            }
        }
        result.add(root.get(ps[0]).alias(alias));
    }
}

@Override
@SuppressWarnings("rawtypes")
public T select(Selection<?>... selections) {
    if (!beforeMethodInvoke()) {
        return (T) this;
    }
    Assert.isTrue(sq == null || selections.length == 1, "selections can only have one in subquery! ");
    Assert.isTrue(sq == null || selections[0] instanceof Expression, "Elements in the selections must implement the " + Expression.class.getName() + " interface in subquery! ");
    Assert.isTrue(sq != null || criteria instanceof CriteriaQuery, "Not supported!");
    if (sq == null) {
        ((CriteriaQuery) criteria).multiselect(selections);
    } else {
        sq.select((Expression) selections[0]);
    }
    for (Selection<?> selection : selections) {
        aliases.add(selection.getAlias());
    }

    return (T) this;
}

/**
 * @param distinctFields
 * @return
 * @throws IllegalArgumentException if the field is not part of the entity
 */
public JpaELFilterImpl distinct(String... distinctFields) {
    if (distinctFields != null) {
        List<Selection> multiSelection = new ArrayList<>();
        for (String f : distinctFields) {
            multiSelection.add(resultRoot.get(f));
        }

        if (distinctFields.length == 1) {
            critQ.select(multiSelection.get(0)).distinct(true);
        } else if (distinctFields.length > 0) {
            critQ.multiselect(multiSelection).distinct(true);
        }
    }

    return this;
}

@Override
public void addSelection(Expression<?> expression, String name) {
    Selection<?> selection = criteriaQuery.getSelection();

    List<Selection<?>> newSelection = new ArrayList<>();
    if (selection != null) {
        if (selection.isCompoundSelection()) {
            newSelection.addAll(selection.getCompoundSelectionItems());
        }
        else {
            newSelection.add(selection);
        }
    }
    newSelection.add(expression);
    criteriaQuery.multiselect(newSelection);
}

/**
 * {@inheritDoc}
 */
@Override
public <T extends BaseEntity> List<Tuple> findByTupleQuery(TupleQueryCriteria<T> criteria) {
    EntityManager em = this.emf.createEntityManager();
    try {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Tuple> cq = cb.createTupleQuery();
        Root<T> root = cq.from(criteria.getEntity());
        return em.createQuery(cq.multiselect(criteria.getSelections()
                .stream()
                .map(root::get)
                .collect(Collectors.toList())
                .toArray(new Selection[LEN_ZERO]))
                .where(cb.and(JpaUtil.getPredicates(criteria.getCriteriaAttributes(), cb, root))))
                .getResultList();
    } catch (RuntimeException ex) {
        LOGGER.error(ex.getMessage(), ex);
        throw new PersistenceException(ex.getMessage(), ex);
    } finally {
        JpaUtil.closeEntityManager(em);
    }
}

/**
 * {@inheritDoc}
 */
@Override
public <T extends BaseEntity, C> List<C> findByCriteriaAndMapConstructor(ConstructorCriteria<T, C> criteria) {
    EntityManager em = this.emf.createEntityManager();
    try {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<C> cq = cb.createQuery(criteria.getConstructorClass());
        Root<T> root = cq.from(criteria.getEntity());
        return em.createQuery(cq.select(cb.construct(criteria.getConstructorClass(), criteria.getSelections()
                .stream()
                .map(root::get)
                .collect(Collectors.toList())
                .toArray(new Selection[LEN_ZERO])))
                .where(JpaUtil.getPredicates(criteria.getCriteriaAttributes(), cb, root)))
                .getResultList();
    } catch (RuntimeException ex) {
        LOGGER.error(ex.getMessage(), ex);
        throw new PersistenceException(ex.getMessage(), ex);
    } finally {
        JpaUtil.closeEntityManager(em);
    }
}

/**
 * {@inheritDoc}
 */
public boolean visit(JpqlSubselect node, CriteriaHolder query) {
    try {
        Subquery<Object> subquery = query.createSubquery();
        node.jjtGetChild(1).visit(this, query);
        node.jjtGetChild(0).visit(this, query);
        List<Selection<?>> selections = query.<List<Selection<?>>>getCurrentValue();
        subquery.select((Expression<Object>)selections.iterator().next());
        query.setValue(subquery);
        for (int i = 2; i < node.jjtGetNumChildren(); i++) {
            node.jjtGetChild(i).visit(this, query);
        }
        query.setValue(subquery);
        return false;
    } finally {
        query.removeSubquery();
    }
}

@Test
public void criteria() {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<ClientEntityBrowserDto> c = cb.createQuery(ClientEntityBrowserDto.class);
    Root<Client> client = c.from(Client.class);

    Join<Client, ClientGroup> clientGroup = client.join("group", JoinType.LEFT);
    Join<Client, ClientStructure> clientStructure = client.join("structure", JoinType.LEFT);
    Join<ClientType, ClientTypeGroup> clientTypeGroup
        = client.join("type", JoinType.LEFT).join("clientTypeGroup", JoinType.LEFT);

    Selection<ClientEntityBrowserDto> selection
        = cb.construct(ClientEntityBrowserDto.class,
                       client.<Integer>get("id"),
                       client.<String>get("number"),
                       client.<String>get("name"),
                       clientTypeGroup.<String>get("name"),
                       clientGroup.<String>get("name"),
                       clientStructure.<String>get("name"));

    c.select(selection);
    c.distinct(true);
    TypedQuery<ClientEntityBrowserDto> query = entityManager.createQuery(c);
    assertTrue(query.getResultList().isEmpty());
}

/**
     * Package-protected method to centralize checking of criteria query multi-selects as defined by the
     * {@link CriteriaQuery#multiselect(List)}  method.
     *
     * @param selections The selection varargs to check
     *
     * @throws IllegalArgumentException If the selection items are not valid per {@link CriteriaQuery#multiselect}
     * documentation.
     * <i>&quot;An argument to the multiselect method must not be a tuple-
     * or array-valued compound selection item.&quot;</i>
     */
    void checkMultiselect(List<Selection<?>> selections) {
//      final HashSet<String> aliases = new HashSet<String>( CollectionHelper.determineProperSizing( selections.size() ) );
//
//      for ( Selection<?> selection : selections ) {
//          if ( selection.isCompoundSelection() ) {
//              if ( selection.getJavaType().isArray() ) {
//                  throw new IllegalArgumentException(
//                          "Selection items in a multi-select cannot contain compound array-valued elements"
//                  );
//              }
//              if ( Tuple.class.isAssignableFrom( selection.getJavaType() ) ) {
//                  throw new IllegalArgumentException(
//                          "Selection items in a multi-select cannot contain compound tuple-valued elements"
//                  );
//              }
//          }
//          if ( StringHelper.isNotEmpty( selection.getAlias() ) ) {
//              boolean added = aliases.add( selection.getAlias() );
//              if ( ! added ) {
//                  throw new IllegalArgumentException( "Multi-select expressions defined duplicate alias : " + selection.getAlias() );
//              }
//          }
//      }
    }

private List<JpaExpression<?>> toExpressions(List<Selection<?>> selections) {
    if ( selections == null || selections.isEmpty() ) {
        return Collections.emptyList();
    }

    final ArrayList<JpaExpression<?>> expressions = new ArrayList<>();
    for ( Selection<?> selection : selections ) {
        if ( selection instanceof JpaExpression ) {
            expressions.add( (JpaExpression) selection );
        }
        else {
            throw new CriteriaBuilderException(
                    "Expecting javax.persistence.criteria.Selection to be " +
                            "JpaExpression, but found " +
                            selection.toString()
            );
        }
    }

    return expressions;
}

public <E> List<Selection<?>> prepareProjectingQuery(MetaJpaConstructor<E,?,?> projection, From<?,? extends E> selection) {
    logger.debug("prepareProjectingQuery({},{})", projection, selection);

    List<Selection<?>> ret;
    if (projection instanceof IdProjection) {
        logger.debug("IdProjection. Replacing selection {} with just Id.", selection);
        ret = Collections.<Selection<?>>newList(selection.get(QueryUtils.<E,Object>id(selection.getJavaType(), em.apply())));
    } else {
        ret = newListOfSize(projection.getParameters().size());
        for (Tuple3<Integer, Attribute<?,?>, Class<?>> t: zip(range(0), projection.getParameters(), projection.getConstructorParameterTypes())) {
            int index = t._1;
            Attribute<?,?> param = t._2;
            Class<?> constuctorParameterType = t._3;
            ret.add(transformSelectionForQuery(param, isId(constuctorParameterType) || isWrapperOfIds(projection, index), selection, projection));
        }
    }

    logger.debug("prepareProjectingQuery -> {}", ret);
    return ret;
}

/**
 * Create a TypedQuery from a request page
 * @param page request page
 * @return new TypedQuery
 */
@SuppressWarnings("unchecked")
private <K> TypedQuery<K> getCriteriaQuery(Page<K> page) {
    CriteriaQuery<K> criteria = getCriteria(page);

    CriteriaQuery<Long> countCriteria = (CriteriaQuery<Long>) getCriteria(page);
    CriteriaBuilder cb = em.getCriteriaBuilder();

    Root<?> root = countCriteria.getRoots().iterator().next();
    countCriteria.select(cb.count(root));

    page.setCount((em.createQuery(countCriteria).getSingleResult())
            .intValue());


    criteria.orderBy(getOrder(page, criteria));

    // Add default select to entity class if none was set.
    if (criteria.getSelection() == null) {
        criteria.select((Selection<? extends K>) root);
    }

    return em.createQuery(criteria);
}

@Override
public <S> S aggregate(Class<S> resultClass, Specification<E> spec, AggregateExpression<E> expression, LockModeType lockMode) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<S> query = builder.createQuery(resultClass);
    Root<E> root = query.from(getDomainClass());
    List<Selection<?>> selectionList = expression.buildExpression(root, query, builder);
    return aggregate(builder, query, root, spec, selectionList, lockMode);
}

@Override
public <S> S sum(Class<S> resultClass, Specification<E> spec, LockModeType lockMode, List<SingularAttribute<E, ? extends Number>> properties) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<S> query = builder.createQuery(resultClass);
    Root<E> root = query.from(getDomainClass());
    List<Selection<?>> selectionList = Lists.newArrayList();
    for (SingularAttribute<E, ? extends Number> property : properties) {
        selectionList.add(builder.sum(root.get(property)));
    }
    return aggregate(builder, query, root, spec, selectionList, lockMode);
}

@SuppressWarnings("unchecked")
public R sum(String expr) {
    Expression<Number> path = QueryFormHelper.getExpression(cb, root, expr);
    query.select((Selection<? extends R>) cb.toDouble(cb.sum(path)));
    TypedQuery<R> typedQuery = em.createQuery(query);
    return typedQuery.getSingleResult();
}

@SuppressWarnings({"unchecked", "rawtypes"})
public List<T> buscarTodos(String... atributos) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery cq = entityManager.getCriteriaBuilder().createQuery();
    Root<T> root = cq.from(entityClass);
    Selection[] selections = new Selection[atributos.length];
    for (int i = 0; i < atributos.length; i++) {
        selections[i] = root.get(atributos[i]);
    }
    cq.select(cb.construct(entityClass, selections));
    cq.orderBy(cb.desc(root.get("id")));
    return entityManager.createQuery(cq).getResultList();
}

@Override
public T select(String... selections) {
    if (!beforeMethodInvoke()) {
        return (T) this;
    }
    List<Selection<?>> list = new ArrayList<Selection<?>>(selections.length);
    for (String selection : selections) {
        parseSelectionStr(list, selection);
    }
    select(list.toArray(new Selection<?>[list.size()]));
    return (T) this;
}

/**
 * @param fields
 * @return
 * @throws IllegalArgumentException if the field is not part of the entity
 */
public JpaELFilterImpl selectFields(String[] fields) {
    List<Selection> multiSelection = new ArrayList<>();

    for (String f : fields) {
        multiSelection.add(resultRoot.get(f));
    }

    critQ.multiselect(multiSelection);
    return this;
}

private <S> S aggregate(CriteriaBuilder builder, CriteriaQuery<S> query, Root<E> root, Specification<E> spec, List<Selection<?>> selectionList, LockModeType lockMode) {
    if (selectionList != null) {
        Predicate predicate = spec.toPredicate(root, query, builder);
        if (predicate != null) {
            query.where(predicate);
        }
        query.multiselect(selectionList);
        return (S) em.createQuery(query).setLockMode(lockMode).getSingleResult();
    }
    return null;
}

@Override
public <S> S aggregate(Class<S> resultClass, Specification<E> spec, AggregateExpression<E> expression, LockModeType lockMode) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<S> query = builder.createQuery(resultClass);
    Root<E> root = query.from(getDomainClass());
    List<Selection<?>> selectionList = expression.buildExpression(root, query, builder);
    return aggregate(builder, query, root, spec, selectionList, lockMode);
}

@Override
public <S> S sum(Class<S> resultClass, Specification<E> spec, LockModeType lockMode, List<String> properties) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<S> query = builder.createQuery(resultClass);
    Root<E> root = query.from(getDomainClass());
    List<Selection<?>> selectionList = Lists.newArrayList();
    for (String property : properties) {
        selectionList.add(builder.sum(getAttributeName(root, property)));
    }
    return aggregate(builder, query, root, spec, selectionList, lockMode);
}

protected List<Selection<?>> getSelections(Root<E> root, CriteriaBuilder builder, String... attributeNames) {
    List<Selection<?>> columns = Lists.newArrayList();
    for(String attributeName : attributeNames) {
        columns.add(builder.sum(this.getAttributeName(root, attributeName)));
    }
    return columns;
}

private synchronized String getAlias(Selection<?> selection) {
    if (selection != null) {
        String alias = selection.getAlias();
        if (alias == null) {
            if (aliasCount >= 1000) {
                aliasCount = 0;
            }
            alias = "shopGeneratedAlias" + aliasCount++;
            selection.alias(alias);
        }
        return alias;
    }
    return null;
}

@Override
@SuppressWarnings({ "rawtypes" })
public long getTotalRowCount() {
    Selection<T> selection = query.getSelection();
    List<Order> orderList = query.getOrderList();
    try {
        CriteriaBuilder builder = em.getCriteriaBuilder();
        Expression<Long> countExpr;

        Set<Root<?>> roots = query.getRoots();
        if (roots.size() != 1) {
            throw new IllegalStateException("cannot compute totalRowCount in case of multiple query roots");
        }
        if (!query.getGroupList().isEmpty()) {
            throw new IllegalStateException("cannot compute totalRowCount for grouped queries");
        }

        // transform query to a count query
        Root root = roots.iterator().next();
        countExpr = builder.count(root);
        query.multiselect(countExpr);
        query.orderBy(new ArrayList<Order>());
        TypedQuery countQuery = em.createQuery(query);

        return (Long) countQuery.getSingleResult();
    }
    finally {
        // transform count query back to regular query
        query.multiselect(selection);
        query.orderBy(orderList);
    }
}

/**
 * {@inheritDoc}
 */
public boolean visit(JpqlSelect node, CriteriaHolder query) {
    node.jjtGetChild(0).visit(this, query);
    List<Selection<?>> selections = query.<List<Selection<?>>>getCurrentValue();
    if (selections.size() == 1) {
        query.getCriteria().select((Selection<?>)selections.iterator().next());
    } else {
        query.getCriteria().multiselect(selections);
    }
    return visit(node);
}

/**
 * {@inheritDoc}
 */
public boolean visit(JpqlSelectExpressions node, CriteriaHolder query) {
    List<Selection<?>> selections = new ArrayList<Selection<?>>();
    for (int i = 0; i < node.jjtGetNumChildren(); i++) {
        node.jjtGetChild(i).visit(this, query);
        selections.add(query.<Selection<?>>getCurrentValue());
    }
    query.setValue(selections);
    return false;
}

/**
 * {@inheritDoc}
 */
public boolean visit(JpqlSelectExpression node, CriteriaHolder query) {
    validateChildCount(node, 1, 2);
    node.jjtGetChild(0).visit(this, query);
    Alias alias = getAlias(node);
    if (alias != null) {
        query.<Selection<?>>getCurrentValue().alias(alias.getName());
    }
    return false;
}

/**
 * {@inheritDoc}
 */
public boolean visit(JpqlConstructor node, CriteriaHolder query) {
    node.jjtGetChild(0).visit(this, query);
    String entityName = query.<String>getCurrentValue();
    Class<?> entityType = ManagedTypeFilter.forModel(metamodel).filter(entityName.trim()).getJavaType();
    List<Selection<?>> constructorParameters = new ArrayList<Selection<?>>();
    query.setValue(constructorParameters);
    for (int i = 1; i < node.jjtGetNumChildren(); i++) {
        node.jjtGetChild(i).visit(this, query);
    }
    Selection<?>[] selection = constructorParameters.toArray(new Selection<?>[constructorParameters.size()]);
    query.setValue(builder.construct(entityType, selection));
    return false;
}