Java EntityManager.createQuery方法代码示例

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
@Nullable
@Override
public User loadUser(String login) throws LoginException {
    // first check if login is a valid user's email, and find the corresponding login name
    // to pass to the super impl
    if (login == null)
        throw new IllegalArgumentException("Login is null");

    EntityManager em = persistence.getEntityManager();
    String queryStr = "select u.loginLowerCase from sec$User u where lower(u.email) = ?1 and (u.active = true or u.active is null)";

    Query q = em.createQuery(queryStr);
    q.setParameter(1, login.toLowerCase());
    List results = q.getResultList();
    if (!results.isEmpty())
        return super.loadUser((String) results.get(0));

    return super.loadUser(login);
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
@Override
public void onBeforeUpdate(Group entity, EntityManager entityManager) {
    if (!persistence.getTools().getDirtyFields(entity).contains("parent"))
        return;

    EntityManager em = persistence.getEntityManager();

    for (GroupHierarchy oldHierarchy : entity.getHierarchyList()) {
        em.remove(oldHierarchy);
    }
    createNewHierarchy(entity, entity.getParent());

    TypedQuery<GroupHierarchy> q = em.createQuery(
            "select h from sec$GroupHierarchy h join fetch h.group " +
                    "where h.parent.id = ?1", GroupHierarchy.class);
    q.setParameter(1, entity);
    List<GroupHierarchy> list = q.getResultList();
    for (GroupHierarchy hierarchy : list) {
        Group dependentGroup = hierarchy.getGroup();
        for (GroupHierarchy depHierarchy : dependentGroup.getHierarchyList()) {
            em.remove(depHierarchy);
        }
        em.remove(hierarchy);
        createNewHierarchy(dependentGroup, dependentGroup.getParent());
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
@Test
public void testQuery_CleanupMode() {
    System.out.println("===================== BEGIN testQuery_CleanupMode =====================");

    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();
        em.setSoftDeletion(false);
        Query query = em.createQuery("select r from sec$Role r where r.name = ?1");
        query.setParameter(1, "roleToBeDeleted");

        List<Role> list = query.getResultList();
        assertTrue(!list.isEmpty());

        tx.commit();
    } finally {
        tx.end();
    }
    System.out.println("===================== END testQuery_CleanupMode =====================");
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
protected int migrateMessagesBatch() {
    List<SendingMessage> resultList;
    Transaction tx = persistence.createTransaction();
    try {
        EntityManager em = persistence.getEntityManager();
        String qstr = "select m from sys$SendingMessage m where m.contentText is not null";
        TypedQuery<SendingMessage> query = em.createQuery(qstr, SendingMessage.class);
        query.setMaxResults(50);
        query.setViewName(View.MINIMAL);

        resultList = query.getResultList();
        tx.commit();
    } finally {
        tx.end();
    }

    if (!resultList.isEmpty()) {
        emailer.migrateEmailsToFileStorage(resultList);
    }

    return resultList.size();
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
@Test
public void testQueryWithoutConditions() {
    System.out.println("===================== BEGIN testQueryWithoutConditions =====================");

    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();
        Query query = em.createQuery("select r from sec$Role r");

        List<Role> list = query.getResultList();
        for (Role role : list) {
            if (role.getId().equals(role2Id)) {
                fail();
            }
        }

        tx.commit();
    } finally {
        tx.end();
    }
    System.out.println("===================== END testQueryWithoutConditions =====================");
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
@Test
public void testOneToMany_Query() {
    System.out.println("===================== BEGIN testOneToMany_Query =====================");

    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();

        Query q = em.createQuery("select u from sec$User u where u.id = ?1");
        q.setParameter(1, userId);
        User user = (User) q.getSingleResult();

        List<UserRole> userRoles = user.getUserRoles();
        assertEquals(1, userRoles.size());
        for (UserRole ur : userRoles) {
            assertNotNull(ur.getRole());
        }

        tx.commit();
    } finally {
        tx.end();
    }
    System.out.println("===================== END testOneToMany_Query =====================");
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
protected User getResultListUserByLoginNamed(User loadedUser, boolean checkView, Consumer<EntityManager> emBuilder, Consumer<Query> queryBuilder) throws Exception {
    User user;
    try (Transaction tx = cont.persistence().createTransaction()) {
        EntityManager em = cont.entityManager();
        if (emBuilder != null) {
            emBuilder.accept(em);
        }
        TypedQuery<User> query = em.createQuery("select u from sec$User u where u.login = :login", User.class);
        query.setCacheable(true);
        query.setParameter("login", "ECTest-" + loadedUser.getId());
        query.setViewName("user.browse");
        if (queryBuilder != null) {
            queryBuilder.accept(query);
        }
        List<User> resultList = query.getResultList();
        user = resultList.isEmpty() ? null : resultList.get(0);
        tx.commit();
    }

    if (user != null && checkView) {
        assertUserBrowseView(user);
    }
    return user;
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
private List<EntityLogItem> getEntityLogItems() {
    Transaction tx;
    List<EntityLogItem> items;
    tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();
        TypedQuery<EntityLogItem> query = em.createQuery(
                "select i from sec$EntityLog i where i.entity = ?1 and i.entityRef.entityId = ?2 order by i.eventTs desc", EntityLogItem.class);
        query.setParameter(1, "sec$User");
        query.setParameter(2, userId);
        items = query.getResultList();

        tx.commit();
    } finally {
        tx.end();
    }
    return items;
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
@Test
public void testQuery() {
    System.out.println("===================== BEGIN testQuery =====================");

    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();
        Query query = em.createQuery("select r from sec$Role r where r.name = ?1");
        query.setParameter(1, "roleToBeDeleted");

        List<Role> list = query.getResultList();
        assertTrue(list.isEmpty());

        tx.commit();
    } finally {
        tx.end();
    }
    System.out.println("===================== END testQuery =====================");
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
@Test
public void testLoadUser() {
    try (Transaction tx = persistence.createTransaction()) {
        EntityManager em = persistence.getEntityManager();
        TypedQuery<User> query = em.createQuery(
                "select u from sec$User u where u.login = :userLogin", User.class);
        query.setParameter("userLogin", "admin");
        List<User> users = query.getResultList();
        tx.commit();
        assertEquals(1, users.size());
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
private void checkConditions(Order order, EntityManager entityManager) {
    Query query = entityManager.createQuery(
            "select count(e) from sample$Order e where e.date = ?1 and e.customer.id = ?2 and e.id <> ?3");
    query.setParameter(1, order.getDate());
    query.setParameter(2, order.getCustomer());
    query.setParameter(3, order.getId());
    Long count = (Long) query.getSingleResult();
    if (count >= 2)
        throw new TooManyOrdersException(order.getCustomer().getName(), order.getDate());
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
protected void compileConstraints(UserSession session, Group group) {
    EntityManager em = persistence.getEntityManager();
    TypedQuery<Constraint> q = em.createQuery("select c from sec$GroupHierarchy h join h.parent.constraints c " +
            "where h.group.id = ?1", Constraint.class);
    q.setParameter(1, group);
    List<Constraint> constraints = q.getResultList();
    List<Constraint> list = new ArrayList<>(constraints);
    list.addAll(group.getConstraints());
    for (Constraint constraint : list) {
        if (Boolean.TRUE.equals(constraint.getIsActive())) {
            session.addConstraint(constraint);
        }
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
protected User loadSubstitutedUser(User substitutedUser, UserSession currentSession, EntityManager em) {
    TypedQuery<User> query = em.createQuery(
            "select s.substitutedUser from sec$User u join u.substitutions s " +
                    "where u.id = ?1 and s.substitutedUser.id = ?2",
            User.class
    );
    query.setParameter(1, currentSession.getUser());
    query.setParameter(2, substitutedUser);
    List<User> list = query.getResultList();
    if (list.isEmpty()) {
        throw new NoResultException("User not found");
    }

    return list.get(0);
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
private void queryWithFlush(Collection<Entity> managedEntities, EntityManager entityManager) {
    if (!managedEntities.stream().anyMatch(e -> e instanceof User && ((User) e).getLogin().startsWith("TxLstnrTst-")))
        return;

    TypedQuery<User> query = entityManager.createQuery("select u from sec$User u where u.login like ?1", User.class);
    query.setParameter(1, "TxLstnrTst-2-%");
    query.setFlushMode(FlushModeType.AUTO);
    User result = query.getFirstResult();
    assertNotNull(result);
}
 

import com.haulmont.cuba.core.EntityManager; //导入方法依赖的package包/类
@Nullable
protected RememberMeToken loadRememberMeToken(User user, String rememberMeToken) {
    EntityManager em = persistence.getEntityManager();
    TypedQuery<RememberMeToken> query = em.createQuery(
            "select rt from sec$RememberMeToken rt where rt.token = :token and rt.user.id = :userId",
            RememberMeToken.class);
    query.setParameter("token", rememberMeToken);
    query.setParameter("userId", user.getId());

    return query.getFirstResult();
}