Example usage for javax.persistence.metamodel SingularAttribute getName

List of usage examples for javax.persistence.metamodel SingularAttribute getName

  1. HOME
  2. Java
  3. javax
  4. javax.persistence.metamodel.*
  5. SingularAttribute
  6. getName

Introduction

In this page you can find the example usage for javax.persistence.metamodel SingularAttribute getName.

Prototype

String getName();

Source Link

Document

Return the name of the attribute.

Usage

From source file:com.dbs.sdwt.jpa.JpaUtil.java

public <T> boolean isPk(ManagedType<T> mt, SingularAttribute<? super T, ?> attr) {
    try {/*from w ww.j  av a  2  s.c  o m*/
        Method m = MethodUtils.getAccessibleMethod(mt.getJavaType(),
                "get" + WordUtils.capitalize(attr.getName()), (Class<?>) null);
        if (m != null && m.getAnnotation(Id.class) != null) {
            return true;
        }

        Field field = mt.getJavaType().getField(attr.getName());
        return field.getAnnotation(Id.class) != null;
    } catch (Exception e) {
        return false;
    }
}

From source file:com.jaxio.jpa.querybyexample.DefaultLuceneQueryBuilder.java

private String buildSubQuery(SingularAttribute<?, ?> property, List<String> terms, SearchParameters sp) {
    StringBuilder subQuery = new StringBuilder();
    subQuery.append("(");
    for (String term : terms) {
        if (subQuery.length() > 1) {
            subQuery.append(" AND ");
        }/*from w w  w. j  a va2  s .  c o  m*/
        if (sp.getSearchSimilarity() != null) {
            subQuery.append(property.getName() + ":" + escapeForFuzzy(lowerCase(term)) + "~"
                    + sp.getSearchSimilarity());
        } else {
            subQuery.append(property.getName() + ":" + escape(lowerCase(term)));
        }
    }
    subQuery.append(")");
    return subQuery.toString();
}

From source file:net.awired.generic.jpa.dao.impl.GenericDaoImpl.java

private Predicate[] BuildFilterPredicates(Root<ENTITY> root, String search, List<String> searchProperties) {
    if (Strings.isNullOrEmpty(search)) {
        return new Predicate[] {};
    }/*from   w w w .j a  va  2 s.  c  o  m*/
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    EntityType<ENTITY> type = entityManager.getMetamodel().entity(entityClass);

    String[] split = search.split(",");

    Set<SingularAttribute<? super ENTITY, ?>> attributes = type.getSingularAttributes();
    List<Predicate> predicates = new ArrayList<Predicate>(split.length * attributes.size());
    for (String searchElem : split) {
        String searchProperty = null;
        if (searchElem.contains(":")) {
            String[] propSearchs = searchElem.trim().split(":", 2);
            searchElem = propSearchs[1];
            searchProperty = propSearchs[0];
        }

        boolean numeric;
        try {
            Double.parseDouble(searchElem);
            numeric = true;
        } catch (Exception e) {
            numeric = false;
        }
        for (SingularAttribute<? super ENTITY, ?> attribute : attributes) {
            if (searchProperties != null && !searchProperties.isEmpty()
                    && !searchProperties.contains(attribute.getName())) {
                continue; // skip this property as its not listed in searchable properties
            }
            if (searchProperty != null && !searchProperty.equals(attribute.getName())) {
                continue; // skip this property as we are searching for specific property
            }
            Class<?> javaType = attribute.getJavaType();
            if (javaType == String.class) {
                @SuppressWarnings("unchecked")
                Predicate like = builder.like(
                        builder.lower(root.get((SingularAttribute<ENTITY, String>) attribute)),
                        "%" + searchElem.toLowerCase().trim() + "%");
                predicates.add(like);
            } else if (numeric && (Number.class.isAssignableFrom(javaType) || javaType == int.class
                    || javaType == short.class || javaType == long.class || javaType == float.class
                    || javaType == double.class || javaType == byte.class)) {
                Predicate like = builder.equal(root.get(attribute), searchElem.toLowerCase().trim());
                predicates.add(like);
            }
            //TODO fancy types
            // enums
            // char   
            // boolean   
        }
    }
    return predicates.toArray(new Predicate[] {});
}

From source file:org.jdal.dao.jpa.JpaDao.java

/**
 * Test if entity is New//ww  w  . ja  va 2 s.c  om
 * @param entity
 * @return true if entity is new, ie not detached
 */
@SuppressWarnings("unchecked")
protected boolean isNew(T entity) {
    SingularAttribute<?, ?> id = getIdAttribute(entity.getClass());
    // try field
    PropertyAccessor pa = PropertyAccessorFactory.forDirectFieldAccess(entity);
    PK key = (PK) pa.getPropertyValue(id.getName());
    if (key == null)
        key = (PK) PropertyAccessorFactory.forBeanPropertyAccess(entity).getPropertyValue(id.getName());

    return key == null || !exists(key, entity.getClass());
}

From source file:org.osiam.resource_server.storage.dao.ResourceDao.java

/**
 * Retrieves a single {@link ResourceEntity} by the given attribute and value.
 * /* w  ww.  j ava2 s . c o  m*/
 * @param attribute
 *        The attribute of the resource entity to retrieve it by
 * @param value
 *        The value of the attribute to compare it to
 * @param clazz
 *        The concrete resource entity class to retrieve (may also be {@link ResourceEntity})
 * @return The matching {@link ResourceEntity}
 * @throws ResourceNotFoundException
 *         If no {@link ResourceEntity} could be found
 * @throws OsiamException
 *         If more than 1 {@link ResourceEntity} was found
 */
public <T extends ResourceEntity, V> T getByAttribute(SingularAttribute<? super T, V> attribute, V value,
        Class<T> clazz) {

    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<T> cq = cb.createQuery(clazz);
    Root<T> resource = cq.from(clazz);

    cq.select(resource).where(cb.equal(resource.get(attribute), value));

    TypedQuery<T> q = em.createQuery(cq);

    try {
        return q.getSingleResult();
    } catch (NoResultException nre) {
        throw new ResourceNotFoundException(
                String.format("Resource with attribute '%s' set to '%s' not found", attribute.getName(), value),
                nre);
    } catch (NonUniqueResultException nure) {
        throw new OsiamException(String.format("Muliple resources with attribute '%s' set to '%s' found",
                attribute.getName(), value), nure);
    }
}

From source file:org.jdal.dao.jpa.JpaDao.java

/**
 * Gets CriteriaQuery for Page Keys/*from  w  w  w  . j a  v  a2  s  . com*/
 * @param page
 * @return CriteriaQuery 
 */
@SuppressWarnings("unchecked")
private TypedQuery<Serializable> getKeyCriteriaQuery(SingularAttribute<? super T, ?> id, Page<T> page) {
    CriteriaQuery<Serializable> keyCriteria = (CriteriaQuery<Serializable>) getCriteria(page);
    Root<T> keyRoot = JpaUtils.findRoot(keyCriteria, getEntityClass());
    keyCriteria.select(keyRoot.<Serializable>get(id.getName()));

    return em.createQuery(keyCriteria);
}

From source file:org.jdal.dao.jpa.JpaDao.java

/**
 * {@inheritDoc}//from  ww  w.  ja  va2s  .com
 */
public List<Serializable> getKeys(Page<T> page) {
    Filter filter = null;
    TypedQuery<Serializable> query = null;
    SingularAttribute<? super T, ?> id = getIdAttribute();
    // try named query
    if (page.getFilter() instanceof Filter) {
        filter = (Filter) page.getFilter();
        String queryString = getQueryString(filter.getFilterName());
        if (queryString != null) {
            String keyQuery = JpaUtils.getKeyQuery(queryString, id.getName());
            // add Order
            if (page.getSortName() != null)
                keyQuery = JpaUtils.addOrder(keyQuery, page.getSortName(), page.getOrder() == Page.Order.ASC);

            query = em.createQuery(keyQuery, Serializable.class);
            applyFilter(query, filter);
        } else {
            query = getKeyCriteriaQuery(id, page);
        }
    } else {
        query = getKeyCriteriaQuery(id, page);
    }

    query.setFirstResult(page.getStartIndex());
    query.setMaxResults(page.getPageSize());

    return query.getResultList();
}

From source file:net.sf.gazpachoquest.qbe.ByExampleSpecification.java

public <T extends Persistable> Specification<T> byExampleOnEntity(final T example, final SearchParameters sp) {
    Validate.notNull(example, "example must not be null");

    return new Specification<T>() {

        @Override//ww w .  ja  v  a 2  s  .  c o  m
        public Predicate toPredicate(final Root<T> rootPath, final CriteriaQuery<?> query,
                final CriteriaBuilder builder) {
            Class<T> type = rootPath.getModel().getBindableJavaType();

            ManagedType<T> mt = em.getMetamodel().entity(type);

            List<Predicate> predicates = new ArrayList<Predicate>();
            predicates.addAll(byExample(mt, rootPath, example, sp, builder));
            predicates.addAll(byExampleOnXToOne(mt, rootPath, example, sp, builder));
            // 1 level deep only
            predicates.addAll(byExampleOnManyToMany(mt, rootPath, example, sp, builder));
            // order by
            query.orderBy(JpaUtil.buildJpaOrders(sp.getOrders(), rootPath, builder));
            return JpaUtil.andPredicate(builder, predicates);
        }

        //https://github.com/jaxio/generated-projects/tree/master/jsf2-spring-conversation/src/main/generated-java/com/jaxio/appli/repository/support

        public <T extends Persistable> List<Predicate> byExample(final ManagedType<T> mt, final Path<T> mtPath,
                final T mtValue, final SearchParameters sp, final CriteriaBuilder builder) {
            List<Predicate> predicates = new ArrayList<Predicate>();
            for (SingularAttribute<? super T, ?> attr : mt.getSingularAttributes()) {
                if (attr.getPersistentAttributeType() == MANY_TO_ONE
                        || attr.getPersistentAttributeType() == ONE_TO_ONE
                        || attr.getPersistentAttributeType() == EMBEDDED
                        || attr.getJavaType().isAssignableFrom(Map.class)) {
                    continue;
                }
                Object attrValue = getValue(mtValue, attr);

                if (attrValue != null) {
                    if (attr.getJavaType() == String.class) {
                        if (isNotEmpty((String) attrValue)) {
                            SingularAttribute<? super T, String> stringAttribute = mt
                                    .getSingularAttribute(attr.getName(), String.class);
                            predicates.add(JpaUtil.stringPredicate(mtPath.get(stringAttribute), attrValue, sp,
                                    builder));
                        }
                    } else {
                        SingularAttribute<? super T, ?> attribute = mt.getSingularAttribute(attr.getName(),
                                attr.getJavaType());
                        // apply equal
                        predicates.add(builder.equal(mtPath.get(attribute), attrValue));
                    }
                }
            }
            return predicates;
        }

        /**
         * Construct a join predicate on collection (eg many to many, List)
         */
        public <T extends Persistable> List<Predicate> byExampleOnManyToMany(final ManagedType<T> mt,
                final Root<T> mtPath, final T mtValue, final SearchParameters sp,
                final CriteriaBuilder builder) {
            List<Predicate> predicates = new ArrayList<Predicate>();
            for (PluralAttribute<T, ?, ?> pa : mt.getDeclaredPluralAttributes()) {
                if (pa.getCollectionType() == PluralAttribute.CollectionType.LIST) {
                    List<?> value = (List<?>) getValue(mtValue, mt.getAttribute(pa.getName()));

                    if (value != null && !value.isEmpty()) {
                        ListJoin<T, ?> join = mtPath.join(mt.getDeclaredList(pa.getName()));
                        predicates.add(join.in(value));
                    }
                }
                if (pa.getCollectionType() == PluralAttribute.CollectionType.SET) {
                    Set<?> value = (Set<?>) getValue(mtValue, mt.getAttribute(pa.getName()));

                    if (value != null && !value.isEmpty()) {
                        SetJoin<T, ?> join = mtPath.join(mt.getDeclaredSet(pa.getName()));
                        predicates.add(join.in(value));
                    }
                }
            }
            return predicates;
        }

        /**
         * Invoke byExample method for each not null x-to-one association
         * when their pk is not set. This allows you
         * to search entities based on an associated entity's properties
         * value.
         */
        @SuppressWarnings("unchecked")
        public <T extends Persistable, M2O extends Persistable> List<Predicate> byExampleOnXToOne(
                final ManagedType<T> mt, final Root<T> mtPath, final T mtValue, final SearchParameters sp,
                final CriteriaBuilder builder) {
            List<Predicate> predicates = new ArrayList<Predicate>();
            for (SingularAttribute<? super T, ?> attr : mt.getSingularAttributes()) {
                if (attr.getPersistentAttributeType() == MANY_TO_ONE
                        || attr.getPersistentAttributeType() == ONE_TO_ONE) { //
                    M2O m2oValue = (M2O) getValue(mtValue, mt.getAttribute(attr.getName()));

                    if (m2oValue != null) {
                        Class<M2O> m2oType = (Class<M2O>) attr.getBindableJavaType();
                        ManagedType<M2O> m2oMt = em.getMetamodel().entity(m2oType);
                        Path<M2O> m2oPath = (Path<M2O>) mtPath.get(attr);
                        predicates.addAll(byExample(m2oMt, m2oPath, m2oValue, sp, builder));
                    }
                }
            }
            return predicates;
        }

        private <T> Object getValue(final T example, final Attribute<? super T, ?> attr) {
            Object value = null;
            try {
                if (attr.getJavaMember() instanceof Method) {
                    value = ((Method) attr.getJavaMember()).invoke(example, new Object[0]);
                } else if (attr.getJavaMember() instanceof Field) {
                    value = ReflectionUtils.getField((Field) attr.getJavaMember(), example);
                }

                if (value instanceof ValueHolderInterface) {
                    value = ((ValueHolderInterface) value).getValue();
                }

            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            }
            return value;
        }

    };

}

From source file:org.apache.ambari.server.api.query.JpaSortBuilder.java

/**
 * Builds the list of sort orders based on the supplied request and JPA
 * predicate visitor./*from w  w  w  .j  av  a  2s . c o m*/
 *
 * @param sortRequests
 *          the Ambari sort request properties to turn into a JPA sort
 *          request. If {@code null} or the {@link SortRequestProperty} list
 *          is null, an empty list is returned.
 * @param visitor
 *          a visitor that knows how to convert the Ambari properties into
 *          {@link SingularAttribute} (not {@code null}).
 * @return a list of sorts or an empty list if none (never {@code null}).
 */
public List<Order> buildSortOrders(SortRequest sortRequest, JpaPredicateVisitor<T> visitor) {

    if (null == sortRequest || null == sortRequest.getProperties()) {
        return Collections.emptyList();
    }

    CriteriaBuilder builder = visitor.getCriteriaBuilder();
    List<SortRequestProperty> sortProperties = sortRequest.getProperties();
    List<Order> sortOrders = new ArrayList<Order>(sortProperties.size());

    for (SortRequestProperty sort : sortProperties) {
        String propertyId = sort.getPropertyId();

        List<? extends SingularAttribute<?, ?>> singularAttributes = visitor.getPredicateMapping(propertyId);

        if (null == singularAttributes || singularAttributes.size() == 0) {
            continue;
        }

        Path<?> path = null;
        for (SingularAttribute<?, ?> singularAttribute : singularAttributes) {
            if (null == path) {

                CriteriaQuery<T> query = visitor.getCriteriaQuery();
                Set<Root<?>> roots = query.getRoots();

                // if there are existing roots; use the existing roots to prevent more
                // roots from being added potentially causing a cartesian product
                // where we don't want one
                if (null != roots && !roots.isEmpty()) {
                    Iterator<Root<?>> iterator = roots.iterator();
                    while (iterator.hasNext()) {
                        Root<?> root = iterator.next();

                        Class<?> visitorEntityClass = visitor.getEntityClass();
                        if (ObjectUtils.equals(visitorEntityClass, root.getJavaType())
                                || ObjectUtils.equals(visitorEntityClass, root.getModel().getJavaType())) {
                            path = root.get(singularAttribute.getName());
                            break;
                        }
                    }
                }

                // no roots exist already which match this entity class, create a new
                // path
                if (null == path) {
                    path = query.from(visitor.getEntityClass()).get(singularAttribute.getName());
                }
            } else {
                path = path.get(singularAttribute.getName());
            }
        }

        Order sortOrder = null;
        if (sort.getOrder() == org.apache.ambari.server.controller.spi.SortRequest.Order.ASC) {
            sortOrder = builder.asc(path);
        } else {
            sortOrder = builder.desc(path);
        }

        sortOrders.add(sortOrder);
    }

    return sortOrders;
}