Examples of javax.persistence.criteria.CriteriaBuilder$SimpleCase

javax.persistence.criteria.CriteriaBuilder
Interface used to build simple case expressions. Case conditions are evaluated in the order in which they are specified.


    protected Object lookupRelationshipType(IdentityObjectRelationshipType relationshipType, EntityManager em) {
        Property<?> relationshipTypeNameProp = modelProperties.get(PROPERTY_RELATIONSHIP_TYPE_NAME);


        if (relationshipTypeNameProp != null) {
            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<?> criteria = builder.createQuery(relationshipTypeNameProp.getDeclaringClass());
            Root<?> root = criteria.from(relationshipTypeNameProp.getDeclaringClass());


            List<Predicate> predicates = new ArrayList<Predicate>();
            predicates.add(builder.equal(root.get(relationshipTypeNameProp.getName()), relationshipType.getName()));
            criteria.where(predicates.toArray(new Predicate[predicates.size()]));


            return em.createQuery(criteria).getSingleResult();
        } else {
            return relationshipType.getName();

View Full Code Here

            throws IdentityException {
        List<IdentityObject> objs = new ArrayList<IdentityObject>();


        EntityManager em = getEntityManager(ctx);


        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<?> criteria = builder.createQuery(identityClass);


        Root<?> root = criteria.from(identityClass);


        Property<?> identityTypeProp = modelProperties.get(PROPERTY_IDENTITY_TYPE);


        List<Predicate> predicates = new ArrayList<Predicate>();


        if (identityType != null) {
            predicates.add(builder.equal(root.get(identityTypeProp.getName()),
                    lookupIdentityType(identityType.getName(), em)));
        }


        criteria.where(predicates.toArray(new Predicate[predicates.size()]));

View Full Code Here

        Property<Object> roleTypeNameProp = modelProperties.get(PROPERTY_ROLE_TYPE_NAME);


        if (roleTypeClass != null) {
            EntityManager em = getEntityManager(ctx);


            CriteriaBuilder builder = em.getCriteriaBuilder();
            CriteriaQuery<?> criteria = builder.createQuery(roleTypeClass);
            criteria.from(roleTypeClass);


            List<?> results = em.createQuery(criteria).getResultList();


            for (Object result : results) {

View Full Code Here


        if (!featuresMetaData.isNamedRelationshipsSupported()) return names;


        EntityManager em = getEntityManager(ctx);


        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<?> criteria = builder.createQuery(relationshipClass);
        Root<?> root = criteria.from(relationshipClass);


        Property<?> identityToProperty = modelProperties.get(PROPERTY_RELATIONSHIP_TO);
        Property<?> relationshipNameProperty = modelProperties.get(PROPERTY_RELATIONSHIP_NAME);


        List<Predicate> predicates = new ArrayList<Predicate>();
        predicates.add(builder.equal(root.get(identityToProperty.getName()),
                lookupIdentity(identity, em)));


        Path<String> rolesOnly = root.get(relationshipNameProperty.getName());
        predicates.add(builder.like(rolesOnly, "%"));


        criteria.where(predicates.toArray(new Predicate[predicates.size()]));


        List<?> results = em.createQuery(criteria).getResultList();
        for (Object result : results) {

View Full Code Here

        EntityManager em = getEntityManager(ctx);


        Property<?> nameProperty = modelProperties.get(PROPERTY_IDENTITY_NAME);
        Property<?> typeProperty = modelProperties.get(PROPERTY_IDENTITY_TYPE);


        CriteriaBuilder builder = em.getCriteriaBuilder();


        CriteriaQuery<?> criteria = builder.createQuery(identityClass);
        Root<?> root = criteria.from(identityClass);


        List<Predicate> predicates = new ArrayList<Predicate>();
        predicates.add(builder.equal(root.get(nameProperty.getName()),
                identity.getName()));
        predicates.add(builder.equal(root.get(typeProperty.getName()),
                lookupIdentityType(identity.getIdentityType().getName(), em)));


        criteria.where(predicates.toArray(new Predicate[predicates.size()]));


        try {
            Object instance = em.createQuery(criteria).getSingleResult();


            // If there is a credential class, delete any credentials
            if (credentialClass != null) {
                Property<?> credentialIdentityProp = modelProperties.get(PROPERTY_CREDENTIAL_IDENTITY);


                criteria = builder.createQuery(credentialClass);
                root = criteria.from(credentialClass);


                predicates = new ArrayList<Predicate>();
                predicates.add(builder.equal(root.get(credentialIdentityProp.getName()),
                        instance));
                criteria.where(predicates.toArray(new Predicate[predicates.size()]));


                List<?> results = em.createQuery(criteria).getResultList();
                for (Object result : results) {
                    em.remove(result);
                }
            }


            // If there is an attribute class, delete any attributes
            if (attributeClass != null) {
                Property<?> attributeIdentityProperty = modelProperties.get(PROPERTY_ATTRIBUTE_IDENTITY);
                criteria = builder.createQuery(attributeClass);
                root = criteria.from(attributeClass);


                predicates = new ArrayList<Predicate>();
                predicates.add(builder.equal(root.get(attributeIdentityProperty.getName()),
                        instance));
                criteria.where(predicates.toArray(new Predicate[predicates.size()]));


                List<?> results = em.createQuery(criteria).getResultList();
                for (Object result : results) {

View Full Code Here

        Property<?> toProperty = modelProperties.get(PROPERTY_RELATIONSHIP_TO);
        Property<?> relationshipTypeProp = modelProperties.get(PROPERTY_RELATIONSHIP_TYPE);


        EntityManager em = getEntityManager(ctx);


        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<?> criteria = builder.createQuery(relationshipClass);
        Root<?> root = criteria.from(relationshipClass);


        List<Predicate> predicates = new ArrayList<Predicate>();
        predicates.add(builder.equal(root.get(fromProperty.getName()),
                lookupIdentity(fromIdentity, em)));
        predicates.add(builder.equal(root.get(toProperty.getName()),
                lookupIdentity(toIdentity, em)));
        predicates.add(builder.equal(root.get(relationshipTypeProp.getName()),
                lookupRelationshipType(relationshipType, em)));


        criteria.where(predicates.toArray(new Predicate[predicates.size()]));


        Object relationship = em.createQuery(criteria).getSingleResult();

View Full Code Here

    public String removeRelationshipName(IdentityStoreInvocationContext ctx,
                                         String name) throws IdentityException, OperationNotSupportedException {
        Property<?> nameProp = modelProperties.get(PROPERTY_ROLE_TYPE_NAME);
        EntityManager em = getEntityManager(ctx);


        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<?> criteria = builder.createQuery(roleTypeClass);
        Root<?> root = criteria.from(roleTypeClass);


        List<Predicate> predicates = new ArrayList<Predicate>();
        predicates.add(builder.equal(root.get(nameProp.getName()), name));
        criteria.where(predicates.toArray((new Predicate[0])));
        Object roleType = em.createQuery(criteria).getSingleResult();
        em.remove(roleType);


        return null;

View Full Code Here

        Object loadedIdentity2 = null;
        if(identity2 != null) {
          loadedIdentity2 = lookupIdentity(identity2, em);
        }
        
        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<?> criteria = builder.createQuery(relationshipClass);
        Root<?> root = criteria.from(relationshipClass);
        
        Property<?> relationshipFromProp = modelProperties.get(PROPERTY_RELATIONSHIP_FROM);
        Property<?> relationshipToProp = modelProperties.get(PROPERTY_RELATIONSHIP_TO);


        List<Predicate> predicates = new ArrayList<Predicate>();
        
        if (identity1 != null) {
            predicates.add(builder.equal(root.get(relationshipFromProp.getName()),
                loadedIdentity1));
        }


        if (identity2 != null) {
            predicates.add(builder.equal(root.get(relationshipToProp.getName()),
                loadedIdentity2));
        }


        criteria.where(predicates.toArray(new Predicate[predicates.size()]));


        List<?> results = em.createQuery(criteria).getResultList();
        for (Object result : results) {
            em.remove(result);
        }


        criteria = builder.createQuery(relationshipClass);
        criteria.from(relationshipClass);


        predicates = new ArrayList<Predicate>();


        if (identity2 != null) {
            predicates.add(builder.equal(root.get(relationshipFromProp.getName()),
                loadedIdentity2));
        }
        if (identity1 != null) {
            predicates.add(builder.equal(root.get(relationshipToProp.getName()),
                loadedIdentity1));
        }


        criteria.where(predicates.toArray(new Predicate[predicates.size()]));

View Full Code Here

            throws IdentityException {
        Set<IdentityObjectRelationship> relationships = new HashSet<IdentityObjectRelationship>();


        EntityManager em = getEntityManager(ctx);


        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<?> criteria = builder.createQuery(relationshipClass);
        Root<?> root = criteria.from(relationshipClass);


        Property<?> relationshipFromProp = modelProperties.get(PROPERTY_RELATIONSHIP_FROM);
        Property<?> relationshipToProp = modelProperties.get(PROPERTY_RELATIONSHIP_TO);
        Property<?> relationshipTypeProp = modelProperties.get(PROPERTY_RELATIONSHIP_TYPE);
        Property<?> relationshipNameProp = modelProperties.get(PROPERTY_RELATIONSHIP_NAME);


        List<Predicate> predicates = new ArrayList<Predicate>();


        if (fromIdentity != null) {
            predicates.add(builder.equal(root.get(relationshipFromProp.getName()),
                    lookupIdentity(fromIdentity, em)));
        }


        if (toIdentity != null) {
            predicates.add(builder.equal(root.get(relationshipToProp.getName()),
                    lookupIdentity(toIdentity, em)));
        }


        if (relationshipType != null) {
            predicates.add(builder.equal(root.get(relationshipTypeProp.getName()),
                    lookupRelationshipType(relationshipType, em)));
        }


        criteria.where(predicates.toArray(new Predicate[predicates.size()]));

View Full Code Here

            boolean named, String name) throws IdentityException {
        Set<IdentityObjectRelationship> relationships = new HashSet<IdentityObjectRelationship>();


        EntityManager em = getEntityManager(ctx);


        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<?> criteria = builder.createQuery(relationshipClass);
        Root<?> root = criteria.from(relationshipClass);


        Property<?> relationshipFromProp = modelProperties.get(PROPERTY_RELATIONSHIP_FROM);
        Property<?> relationshipToProp = modelProperties.get(PROPERTY_RELATIONSHIP_TO);
        Property<?> relationshipTypeProp = modelProperties.get(PROPERTY_RELATIONSHIP_TYPE);
        Property<?> relationshipNameProp = modelProperties.get(PROPERTY_RELATIONSHIP_NAME);


        List<Predicate> predicates = new ArrayList<Predicate>();


        if (parent) {
            predicates.add(builder.equal(root.get(relationshipFromProp.getName()),
                    lookupIdentity(identity, em)));
        } else {
            predicates.add(builder.equal(root.get(relationshipToProp.getName()),
                    lookupIdentity(identity, em)));
        }


        if (relationshipType != null) {
            predicates.add(builder.equal(root.get(relationshipTypeProp.getName()),
                    lookupRelationshipType(relationshipType, em)));
        }


        if (named) {
            if (name != null) {
                predicates.add(builder.equal(root.get(relationshipNameProp.getName()),
                        name));
            } else {
                predicates.add(builder.isNotNull(root.get(relationshipNameProp.getName())));
            }
        }


        criteria.where(predicates.toArray(new Predicate[predicates.size()]));

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of javax.persistence.criteria.CriteriaBuilder$SimpleCase

$.MemberDaoImpl

$.MemberRepository

br.com.lawoffice.persistencia.ejb.HistoricoContaDaoBean

br.com.lawoffice.persistencia.ejb.LancamentoDaoBean

br.com.mystudies.jpa.criteria.api.ClienteDao

br.com.mystudies.service.persistence.SprintDaoBean

br.gov.frameworkdemoiselle.template.JPACrud

com.ctp.cdi.query.criteria.QueryCriteria

com.darkhonor.rage.libs.dataaccess.CategoryDAO

com.darkhonor.rage.libs.dataaccess.CourseDAO

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.