How to use

setParameter

method

in

javax.persistence.TypedQuery

  @Override
  public List<Account> findByCustomer(Customer customer) {

    TypedQuery<Account> query = em.createQuery("select a from Account a where a.customer = ?1", Account.class);
    query.setParameter(1, customer);

    return query.getResultList();
  }
}

  @Override
  public List<AdminUser> readAdminUserByEmail(String emailAddress) {
    TypedQuery<AdminUser> query = em.createNamedQuery("BC_READ_ADMIN_USER_BY_EMAIL", AdminUser.class);
    query.setParameter("email", emailAddress);
    return query.getResultList();
  }
}

  @Override
  public Customer findByEmailAddress(EmailAddress emailAddress) {

    TypedQuery<Customer> query = em.createQuery("select c from Customer c where c.emailAddress = :email",
        Customer.class);
    query.setParameter("email", emailAddress);

    return query.getSingleResult();
  }
}

@Override
public Optional<Long> lastSequenceNumberFor(String aggregateIdentifier) {
  List<Long> results = entityManager().createQuery(
      "SELECT MAX(e.sequenceNumber) FROM " + domainEventEntryEntityName()
          + " e WHERE e.aggregateIdentifier = :aggregateId", Long.class)
                    .setParameter("aggregateId", aggregateIdentifier)
                    .getResultList();
  if (results.size() == 0) {
    return Optional.empty();
  }
  return Optional.ofNullable(results.get(0));
}

@Override
public URLHandler findURLHandlerByURI(String uri) {
  TypedQuery<URLHandler> query = em.createNamedQuery("BC_READ_BY_INCOMING_URL", URLHandler.class);
  query.setParameter("incomingURL", uri);
  query.setHint(QueryHints.HINT_CACHEABLE, true);
  List<URLHandler> results = query.getResultList();
  if (results != null && !results.isEmpty()) {
    return results.get(0);
  } else {
    return null;
  }
}

Customer customer = entityManager.createQuery(
  "select c " +
  "from Customer c " +
  "join fetch a.country " +
  "where c.id = :id", Customer.class )
.setParameter( "id", 1L )
.getSingleResult();
.get( entityManager )
.createQuery()
.forEntitiesAtRevision( Customer.class, revisions.get( revisions.size() - 1 ) )
.traverseRelation( "address", JoinType.INNER, "a" )
.traverseRelation( "country", JoinType.INNER, "cn" )

@Test
public void test_jpql_api_hibernate_named_query_example() {
  doInJPA( this::entityManagerFactory, entityManager -> {
    //tag::jpql-api-hibernate-named-query-example[]
    Phone phone = entityManager
      .createNamedQuery( "get_phone_by_number", Phone.class )
      .setParameter( "number", "123-456-7890" )
      .getSingleResult();
    //end::jpql-api-hibernate-named-query-example[]
    assertNotNull( phone );
  });
}

@Test
public void test_hql_collection_expressions_example_1() {
  doInJPA( this::entityManagerFactory, entityManager -> {
    Call call = entityManager.createQuery( "select c from Call c", Call.class).getResultList().get( 1 );
    //tag::hql-collection-expressions-example[]
    List<Phone> phones = entityManager.createQuery(
      "select p " +
      "from Phone p " +
      "where maxelement( p.calls ) = :call", Phone.class )
    .setParameter( "call", call )
    .getResultList();
    //end::hql-collection-expressions-example[]
    assertEquals(1, phones.size());
  });
}

public AdminUser readAdminUserByUserName(String userName) {
  TypedQuery<AdminUser> query = em.createNamedQuery("BC_READ_ADMIN_USER_BY_USERNAME", AdminUser.class);
  query.setHint(QueryHints.HINT_CACHEABLE, true);
  query.setHint(QueryHints.HINT_CACHE_REGION, "blAdminSecurityVolatileQuery");
  query.setParameter("userName", userName);
  List<AdminUser> users = query.getResultList();
  //TODO rewrite on streams when upgraded to java 8
  Iterator<AdminUser> iterator = users.iterator();
  while (iterator.hasNext()){
    AdminUser user = iterator.next();
    if(Status.class.isAssignableFrom(user.getClass())) {
      if('Y' == ((Status)user).getArchived()) {
        iterator.remove();
      }
    }
  }
  if (users != null && !users.isEmpty()) {
    return users.get(0);
  }
  return null;
}

  @Override
  public List<Customer> findByLastname(String lastname, int page, int pageSize) {

    TypedQuery<Customer> query = em.createQuery("select c from Customer c where c.lastname = ?1", Customer.class);

    query.setParameter(1, lastname);
    query.setFirstResult(page * pageSize);
    query.setMaxResults(pageSize);

    return query.getResultList();
  }
}

@Override
public boolean existsById(ID id) {
  Assert.notNull(id, ID_MUST_NOT_BE_NULL);
  if (entityInformation.getIdAttribute() == null) {
    return findById(id).isPresent();
  }
  String placeholder = provider.getCountQueryPlaceholder();
  String entityName = entityInformation.getEntityName();
  Iterable<String> idAttributeNames = entityInformation.getIdAttributeNames();
  String existsQuery = QueryUtils.getExistsQueryString(entityName, placeholder, idAttributeNames);
  TypedQuery<Long> query = em.createQuery(existsQuery, Long.class);
  if (!entityInformation.hasCompositeId()) {
    query.setParameter(idAttributeNames.iterator().next(), id);
    return query.getSingleResult() == 1L;
  }
  for (String idAttributeName : idAttributeNames) {
    Object idAttributeValue = entityInformation.getCompositeIdAttributeValue(id, idAttributeName);
    boolean complexIdParameterValueDiscovered = idAttributeValue != null
        && !query.getParameter(idAttributeName).getParameterType().isAssignableFrom(idAttributeValue.getClass());
    if (complexIdParameterValueDiscovered) {
      // fall-back to findById(id) which does the proper mapping for the parameter.
      return findById(id).isPresent();
    }
    query.setParameter(idAttributeName, idAttributeValue);
  }
  return query.getSingleResult() == 1L;
}

@Override
public List<OrderMultishipOption> readOrderMultishipOptions(final Long orderId) {
  TypedQuery<OrderMultishipOption> query = em.createNamedQuery("BC_READ_MULTISHIP_OPTIONS_BY_ORDER_ID", OrderMultishipOption.class);
  query.setParameter("orderId", orderId);
  return query.getResultList();
}

@Override
public Long count(final String sourceName, final String databaseName, final String tableName) {
  final TypedQuery<Long> query = em.get().createNamedQuery(Partition.NAME_QUERY_GET_COUNT_FOR_TABLE,
    Long.class);
  query.setParameter("sourceName", sourceName);
  query.setParameter("databaseName", databaseName);
  query.setParameter("tableName", tableName);
  return query.getSingleResult();
}

@Test
public void test_hql_collection_expressions_example_2() {
  doInJPA( this::entityManagerFactory, entityManager -> {
    Call call = entityManager.createQuery( "select c from Call c", Call.class).getResultList().get( 0 );
    //tag::hql-collection-expressions-example[]
    List<Phone> phones = entityManager.createQuery(
      "select p " +
      "from Phone p " +
      "where minelement( p.calls ) = :call", Phone.class )
    .setParameter( "call", call )
    .getResultList();
    //end::hql-collection-expressions-example[]
    assertEquals(1, phones.size());
  });
}

@Override
public <S> Entry<S> loadSaga(Class<S> sagaType, String sagaIdentifier) {
  EntityManager entityManager = entityManagerProvider.getEntityManager();
  final Class<? extends SimpleSerializedObject<?>> serializedObjectType = serializedObjectType();
  List<? extends SimpleSerializedObject<?>> serializedSagaList =
      entityManager.createNamedQuery(LOAD_SAGA_NAMED_QUERY, serializedObjectType)
             .setParameter("sagaId", sagaIdentifier)
             .setMaxResults(1)
             .getResultList();
  if (serializedSagaList == null || serializedSagaList.isEmpty()) {
    return null;
  }
  final SimpleSerializedObject<?> serializedSaga = serializedSagaList.get(0);
  S loadedSaga = serializer.deserialize(serializedSaga);
  Set<AssociationValue> associationValues = loadAssociationValues(entityManager, sagaType, sagaIdentifier);
  if (logger.isDebugEnabled()) {
    logger.debug("Loaded saga id [{}] of type [{}]", sagaIdentifier, serializedSaga.getType().getName());
  }
  return new EntryImpl<>(associationValues, loadedSaga);
}

@Override
public int[] fetchSegments(String processorName) {
  EntityManager entityManager = entityManagerProvider.getEntityManager();
  final List<Integer> resultList = entityManager.createQuery(
      "SELECT te.segment FROM TokenEntry te "
          + "WHERE te.processorName = :processorName ORDER BY te.segment ASC",
      Integer.class
  ).setParameter("processorName", processorName).getResultList();
  return resultList.stream().mapToInt(i -> i).toArray();
}

@Test
public void test_hql_collection_qualification_associations_5() {
  doInJPA( this::entityManagerFactory, entityManager -> {
    Long id = 1L;
    Integer phoneIndex = 0;
    //tag::hql-collection-qualification-example[]
    // Sum all call durations for a given Phone of a specific Person
    Long duration = entityManager.createQuery(
      "select sum(ch.duration) " +
      "from Person pr " +
      "join pr.phones ph " +
      "join ph.callHistory ch " +
      "where ph.id = :id " +
      "  and index(ph) = :phoneIndex", Long.class )
    .setParameter( "id", id )
    .setParameter( "phoneIndex", phoneIndex )
    .getSingleResult();
    //end::hql-collection-qualification-example[]
    assertEquals(45, duration.intValue());
  });
}

@Override
public List<OrderMultishipOption> readOrderItemOrderMultishipOptions(final Long orderItemId) {
  TypedQuery<OrderMultishipOption> query = em.createNamedQuery("BC_READ_MULTISHIP_OPTIONS_BY_ORDER_ITEM_ID", OrderMultishipOption.class);
  query.setParameter("orderItemId", orderItemId);
  return query.getResultList();
}

@Test
public void test_hql_collection_expressions_example_5() {
  doInJPA( this::entityManagerFactory, entityManager -> {
    Call call = entityManager.createQuery( "select c from Call c", Call.class).getResultList().get( 0 );
    Phone phone = call.getPhone();
    //tag::hql-collection-expressions-example[]
    List<Person> persons = entityManager.createQuery(
      "select p " +
      "from Person p " +
      "where :phone = some elements ( p.phones )", Person.class )
    .setParameter( "phone", phone )
    .getResultList();
    //end::hql-collection-expressions-example[]
    assertEquals(1, persons.size());
  });
}

/**
 * On generic typed named query.
 */
@Test
public void onGenericTypedNamedQuery()
{
  Object p1 = prepareMongoInstance("1", 10);
  Object p2 = prepareMongoInstance("2", 20);
  Object p3 = prepareMongoInstance("3", 15);
  em.persist(p1);
  em.persist(p2);
  em.persist(p3);
  TypedQuery<Object> query = em.createNamedQuery("mongo.named.query", Object.class);
  query.setParameter("name", "vivek");
  List<Object> results = query.getResultList();
  Assert.assertEquals(3, results.size());
  Assert.assertEquals(PersonMongo.class, results.get(0).getClass());
}