Пример #1
1
  @Override
  public Set<String> getTagsSuggest(String url) {
    String hashUrl = MD5Util.md5Hex(url);

    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<Tuple> query = cb.createTupleQuery();

    Root<Bookmark> root = query.from(Bookmark.class);
    // joins
    SetJoin<Bookmark, String> tagsJoin = root.joinSet("tags");

    query.select(cb.tuple(tagsJoin.alias("tag"), cb.count(tagsJoin).alias("count_tags")));
    query.where(cb.equal(root.get("hashUrl"), hashUrl));
    query.groupBy(tagsJoin);
    query.orderBy(cb.desc(cb.count(tagsJoin)));

    // top five tags
    List<Tuple> result = entityManager.createQuery(query).setMaxResults(5).getResultList();

    Set<String> topTags = new HashSet<String>();

    for (Tuple t : result) {
      topTags.add((String) t.get("tag"));
    }

    return topTags;
  }
Пример #2
0
  @Override
  public Map<String, Long> countTagsByUser(String userName) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<Tuple> query = cb.createTupleQuery();

    Root<Bookmark> root = query.from(Bookmark.class);
    // joins
    SetJoin<Bookmark, String> tagsJoin = root.joinSet("tags");
    Join<Bookmark, User> userJoin = root.join("user");

    query.select(cb.tuple(tagsJoin.alias("tag"), cb.count(tagsJoin).alias("count_tags")));
    query.where(cb.equal(userJoin.get("userName"), userName));
    query.groupBy(tagsJoin);
    query.orderBy(cb.desc(cb.count(tagsJoin)));

    List<Tuple> result = entityManager.createQuery(query).setMaxResults(30).getResultList();

    Map<String, Long> tagRanking = new TreeMap<String, Long>();

    for (Tuple t : result) {
      tagRanking.put((String) t.get("tag"), (Long) t.get("count_tags"));
    }

    return tagRanking;
  }
  @Test
  public void testInvalidTupleIndexAccess() {
    EntityManager em = entityManagerFactory().createEntityManager();
    em.getTransaction().begin();
    Customer c1 = new Customer();
    c1.setId("c1");
    c1.setAge(18);
    c1.setName("Bob");
    em.persist(c1);
    em.getTransaction().commit();
    em.close();

    // the actual assertion block
    em = entityManagerFactory().createEntityManager();
    em.getTransaction().begin();
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Tuple> criteria = builder.createTupleQuery();
    Root<Customer> customerRoot = criteria.from(Customer.class);
    criteria.multiselect(customerRoot.get(Customer_.name), customerRoot.get(Customer_.age));
    List<Tuple> results = em.createQuery(criteria).getResultList();
    assertEquals(1, results.size());
    Tuple tuple = results.get(0);
    try {
      tuple.get(99);
      fail("99 is invalid index");
    } catch (IllegalArgumentException expected) {
    }

    try {
      tuple.get(99, String.class);
      fail("99 is invalid index");
    } catch (IllegalArgumentException expected) {
    }

    tuple.get(0, String.class);
    tuple.get(1, Integer.class);

    try {
      tuple.get(0, java.util.Date.class);
      fail("Date is invalid type");
    } catch (IllegalArgumentException expected) {
    }

    em.getTransaction().commit();
    em.close();

    em = entityManagerFactory().createEntityManager();
    em.getTransaction().begin();
    em.createQuery("delete Customer").executeUpdate();
    em.getTransaction().commit();
    em.close();
  }
  @Test
  public void testVariousTupleAccessMethods() {
    EntityManager em = entityManagerFactory().createEntityManager();
    em.getTransaction().begin();
    Customer c1 = new Customer();
    c1.setId("c1");
    c1.setAge(18);
    c1.setName("Bob");
    em.persist(c1);
    em.getTransaction().commit();
    em.close();

    em = entityManagerFactory().createEntityManager();
    em.getTransaction().begin();

    final CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Tuple> criteria = builder.createTupleQuery();
    Root<Customer> customerRoot = criteria.from(Customer.class);
    Path<String> namePath = customerRoot.get(Customer_.name);
    namePath.alias("NAME");
    Path<Integer> agePath = customerRoot.get(Customer_.age);
    agePath.alias("AGE");
    criteria.multiselect(namePath, agePath);

    List<Tuple> results = em.createQuery(criteria).getResultList();
    Tuple tuple = results.get(0);
    assertNotNull(tuple);
    assertNotNull(tuple.get("NAME"));
    assertNotNull(tuple.get("NAME", String.class));
    try {
      tuple.get("NAME", Date.class);
      fail("Accessing Customer#name tuple as Date should have thrown exception");
    } catch (IllegalArgumentException expected) {
    }

    em.getTransaction().commit();
    em.close();

    em = entityManagerFactory().createEntityManager();
    em.getTransaction().begin();
    em.createQuery("delete Customer").executeUpdate();
    em.getTransaction().commit();
    em.close();
  }
  @Test
  public void testTuple() {
    EntityManager em = entityManagerFactory().createEntityManager();

    em.getTransaction().begin();
    Customer c1 = new Customer();
    c1.setId("c1");
    c1.setAge(18);
    c1.setName("Bob");
    em.persist(c1);
    em.getTransaction().commit();
    em.close();

    em = entityManagerFactory().createEntityManager();
    em.getTransaction().begin();
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Tuple> criteria = builder.createTupleQuery();
    Root<Customer> customerRoot = criteria.from(Customer.class);
    Path<String> namePath = customerRoot.get(Customer_.name);
    Path<Integer> agePath = customerRoot.get(Customer_.age);
    agePath.alias("age");
    criteria.multiselect(namePath, agePath);
    List<Tuple> results = em.createQuery(criteria).getResultList();
    assertEquals(1, results.size());
    Object resultElement = results.get(0);
    assertTrue("Check  result 'row' as Tuple", Tuple.class.isInstance(resultElement));
    Tuple resultElementTuple = (Tuple) resultElement;
    Object[] tupleArray = resultElementTuple.toArray();
    assertEquals(2, tupleArray.length);
    assertEquals(tupleArray[0], resultElementTuple.get(0));
    assertEquals(resultElementTuple.get(namePath), resultElementTuple.get(0));
    assertEquals(tupleArray[1], resultElementTuple.get(1));
    assertEquals(resultElementTuple.get(agePath), resultElementTuple.get(1));
    assertEquals(resultElementTuple.get(agePath), resultElementTuple.get("age"));
    em.getTransaction().commit();
    em.close();

    em = entityManagerFactory().createEntityManager();
    em.getTransaction().begin();
    em.createQuery("delete Customer").executeUpdate();
    em.getTransaction().commit();
    em.close();
  }
 @Test
 public void testIllegalArgumentExceptionBuildingTupleWithSameAliases() {
   EntityManager em = entityManagerFactory().createEntityManager();
   em.getTransaction().begin();
   final CriteriaBuilder builder = em.getCriteriaBuilder();
   CriteriaQuery<Tuple> criteria = builder.createTupleQuery();
   Root<Customer> customerRoot = criteria.from(Customer.class);
   Path<String> namePath = customerRoot.get(Customer_.name);
   namePath.alias("age");
   Path<Integer> agePath = customerRoot.get(Customer_.age);
   agePath.alias("age");
   try {
     criteria.multiselect(namePath, agePath);
     fail(
         "Attempt to define multi-select with same aliases should have thrown IllegalArgumentException");
   } catch (IllegalArgumentException expected) {
   }
   em.getTransaction().commit();
   em.close();
 }
Пример #7
0
  /**
   * This query demonstrates a query for multiple properties -- same as above -- except this example
   * used a Tuple return type and select aliases
   */
  @Test
  public void testMultiSelectTuple() {
    log.info("*** testMultiSelectTuple() ***");

    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Tuple> qdef = cb.createTupleQuery();

    // select c.firstName as firstName, c.hireDate as hireDate from Clerk c
    Root<Clerk> c = qdef.from(Clerk.class);
    qdef.select(
        cb.tuple(c.get("firstName").alias("firstName"), c.get("hireDate").alias("hireDate")));

    TypedQuery<Tuple> query = em.createQuery(qdef);
    List<Tuple> results = query.getResultList();
    assertTrue("no results", results.size() > 0);
    for (Tuple result : results) {
      assertEquals("unexpected result length", 2, result.getElements().size());
      String firstName = result.get("firstName", String.class);
      Date hireDate = result.get("hireDate", Date.class);
      log.info("firstName=" + firstName + " hireDate=" + hireDate);
    }
  }
Пример #8
0
  public static <T> List<T> queryEntities(EntityManager em, Class<T> entity, QueryParameters q) {

    if (q == null)
      throw new IllegalArgumentException(
          "Query parameters can't be null. "
              + "If you don't have any parameters either pass a empty object or "
              + "use the queryEntities(EntityManager, Class<T>) method.");

    log.finest("Querying entity: '" + entity.getSimpleName() + "' with parameters: " + q);

    CriteriaBuilder cb = em.getCriteriaBuilder();

    CriteriaQuery<T> cq = cb.createQuery(entity);

    CriteriaQuery<Tuple> ct = cb.createTupleQuery();

    Root<T> r = cq.from(entity);
    Root<T> rt = ct.from(entity);

    if (!q.getFilters().isEmpty()) {

      Predicate whereQuery = createWhereQuery(cb, r, q);
      Predicate whereQueryTuple = createWhereQuery(cb, rt, q);

      cq.where(whereQuery);
      ct.where(whereQueryTuple);
    }

    if (!q.getOrder().isEmpty()) {

      List<Order> orders = createOrderQuery(cb, r, q);
      List<Order> ordersTuple = createOrderQuery(cb, rt, q);

      cq.orderBy(orders);
      ct.orderBy(ordersTuple);
    }

    cq.select(r);
    ct.multiselect(createFieldsSelect(rt, q, getEntityIdField(em, entity)));

    TypedQuery<T> tq = em.createQuery(cq);
    TypedQuery<Tuple> tqt = em.createQuery(ct);

    if (q.getLimit() != null && q.getLimit() > -1) {

      tq.setMaxResults(q.getLimit().intValue());
      tqt.setMaxResults(q.getLimit().intValue());
    }

    if (q.getOffset() != null && q.getOffset() > -1) {

      tq.setFirstResult(q.getOffset().intValue());
      tqt.setFirstResult(q.getOffset().intValue());
    }

    if (q.getFields().isEmpty()) {

      return tq.getResultList();
    } else {

      return createEntityFromTuple(tqt.getResultList(), entity);
    }
  }