下面列出了javax.persistence.metamodel.Bindable#javax.persistence.criteria.Join 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public StorageFileEntity getStorageFileByStorageNameAndFilePath(String storageName, String filePath)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<StorageFileEntity> criteria = builder.createQuery(StorageFileEntity.class);
// The criteria root is the storage files.
Root<StorageFileEntity> storageFileEntity = criteria.from(StorageFileEntity.class);
// Join to the other tables we can filter on.
Join<StorageFileEntity, StorageUnitEntity> storageUnitEntity = storageFileEntity.join(StorageFileEntity_.storageUnit);
Join<StorageUnitEntity, StorageEntity> storageEntity = storageUnitEntity.join(StorageUnitEntity_.storage);
// Create the standard restrictions (i.e. the standard where clauses).
Predicate filePathRestriction = builder.equal(storageFileEntity.get(StorageFileEntity_.path), filePath);
Predicate storageNameRestriction = builder.equal(builder.upper(storageEntity.get(StorageEntity_.name)), storageName.toUpperCase());
criteria.select(storageFileEntity).where(builder.and(filePathRestriction, storageNameRestriction));
return executeSingleResultQuery(criteria,
String.format("Found more than one storage file with parameters {storageName=\"%s\"," + " filePath=\"%s\"}.", storageName, filePath));
}
@Override
public List<CategoryOptionCombo> getCategoryOptionCombosByGroupUid( String groupUid )
{
CriteriaBuilder builder = getCriteriaBuilder();
CriteriaQuery<CategoryOptionCombo> query = builder.createQuery( CategoryOptionCombo.class );
Root<CategoryOptionCombo> root = query.from( CategoryOptionCombo.class );
Join<Object, Object> joinCatOption = root.join( "categoryOptions", JoinType.INNER );
Join<Object, Object> joinCatOptionGroup = joinCatOption.join( "groups", JoinType.INNER );
query.where( builder.equal( joinCatOptionGroup.get( "uid" ), groupUid ) );
return getSession().createQuery( query ).list();
}
@Override
public Optional<Comment> findComment(String slug, Long commentId, Long authorId) {
CriteriaBuilder builder = getCriteriaBuilder();
CriteriaQuery<Comment> criteriaQuery = getCriteriaQuery(builder);
Root<Comment> comment = getRoot(criteriaQuery);
Join<Comment, Article> article = comment.join("article");
Join<Comment, User> author = comment.join("author");
criteriaQuery.select(comment);
criteriaQuery.where(
builder.and(
builder.equal(builder.upper(article.get("slug")), slug.toUpperCase().trim()),
builder.equal(comment.get("id"), commentId),
builder.equal(author.get("id"), authorId)));
return Optional.ofNullable(getSingleResult(criteriaQuery));
}
@Override
public Predicate getPredicate(Root<Project> root, CriteriaBuilder builder) {
Join<?, ?> userAuthorizationJoin = root.join(Project.PROP_USER_AUTHORIZATIONS, JoinType.LEFT);
userAuthorizationJoin.on(builder.and(
builder.equal(userAuthorizationJoin.get(UserAuthorization.PROP_ROLE), Role.OWNER_ID),
builder.equal(userAuthorizationJoin.get(UserAuthorization.PROP_USER), user)));
if (user.getGroups().isEmpty()) {
return userAuthorizationJoin.isNotNull();
} else {
Join<?, ?> groupAuthorizationJoin = root.join(Project.PROP_GROUP_AUTHORIZATIONS, JoinType.LEFT);
groupAuthorizationJoin.on(builder.and(
builder.equal(groupAuthorizationJoin.get(GroupAuthorization.PROP_ROLE), Role.OWNER_ID),
groupAuthorizationJoin.get(GroupAuthorization.PROP_GROUP).in(user.getGroups())));
return builder.or(userAuthorizationJoin.isNotNull(), groupAuthorizationJoin.isNotNull());
}
}
@Override
public JobDefinitionEntity getJobDefinitionByAltKey(String namespace, String jobName)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<JobDefinitionEntity> criteria = builder.createQuery(JobDefinitionEntity.class);
// The criteria root is the job definition.
Root<JobDefinitionEntity> jobDefinition = criteria.from(JobDefinitionEntity.class);
// Join to the other tables we can filter on.
Join<JobDefinitionEntity, NamespaceEntity> namespaceJoin = jobDefinition.join(JobDefinitionEntity_.namespace);
// Create the standard restrictions (i.e. the standard where clauses).
Predicate namespaceRestriction = builder.equal(builder.upper(namespaceJoin.get(NamespaceEntity_.code)), namespace.toUpperCase());
Predicate jobNameRestriction = builder.equal(builder.upper(jobDefinition.get(JobDefinitionEntity_.name)), jobName.toUpperCase());
criteria.select(jobDefinition).where(builder.and(namespaceRestriction, jobNameRestriction));
return executeSingleResultQuery(criteria,
String.format("Found more than one Activiti job definition with parameters {namespace=\"%s\", jobName=\"%s\"}.", namespace, jobName));
}
@Override
public final Predicate getPredicate(Root<Issue> root, CriteriaBuilder builder) {
Join<?, ?> join = root.join(Issue.PROP_FIELDS, JoinType.LEFT);
Predicate valuePredicate = getValuePredicate(join, builder);
if (valuePredicate != null) {
join.on(builder.and(
builder.equal(join.get(IssueField.PROP_NAME), getFieldName()),
getValuePredicate(join, builder)));
return join.isNotNull();
} else {
join.on(builder.and(
builder.equal(join.get(IssueField.PROP_NAME), getFieldName()),
builder.or(builder.isNull(join.get(IssueField.PROP_VALUE)))));
Join<?, ?> join2 = root.join(Issue.PROP_FIELDS, JoinType.LEFT);
join2.on(builder.equal(join2.get(IssueField.PROP_NAME), getFieldName()));
return builder.or(join.isNotNull(), join2.isNull());
}
}
@SuppressWarnings({ "unchecked" })
private void renderJoins(
StringBuilder jpaqlQuery,
RenderingContext renderingContext,
Collection<Join<?,?>> joins) {
if ( joins == null ) {
return;
}
for ( Join join : joins ) {
( (FromImplementor) join ).prepareAlias( renderingContext );
jpaqlQuery.append( renderJoinType( join.getJoinType() ) )
.append( ( (FromImplementor) join ).renderTableExpression( renderingContext ) );
renderJoins( jpaqlQuery, renderingContext, join.getJoins() );
renderFetches( jpaqlQuery, renderingContext, join.getFetches() );
}
}
@Decision(DELETE)
public Void delete(UserPermissionPrincipal principal,
ActionRecord actionRecord,
RestContext context,
EntityManager em) {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<PasswordCredential> query = cb.createQuery(PasswordCredential.class);
Root<PasswordCredential> passwordCredentialRoot = query.from(PasswordCredential.class);
Join<User, PasswordCredential> userRoot = passwordCredentialRoot.join("user");
query.where(cb.equal(userRoot.get("name"), principal.getName()));
EntityTransactionManager tx = new EntityTransactionManager(em);
em.createQuery(query)
.getResultStream()
.findAny()
.ifPresent(passwordCredential -> tx.required(() -> {
em.remove(passwordCredential);
config.getHookRepo().runHook(AFTER_DELETE_PASSWORD_CREDENTIAL, context);
}));
actionRecord.setActionType(ActionType.PASSWORD_DELETED);
actionRecord.setActor(principal.getName());
return null;
}
@Decision(EXISTS)
public boolean exists(Parameters params, Application application, RestContext context, EntityManager em) {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Realm> query = cb.createQuery(Realm.class);
Root<Realm> realmRoot = query.from(Realm.class);
Join<Application, Realm> applicationJoin = realmRoot.join("application");
query.where(cb.equal(realmRoot.get("name"), params.get("realmName")),
cb.equal(applicationJoin.get("id"), application.getId()));
Realm realm = em.createQuery(query)
.setHint("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH)
.getResultStream().findAny().orElse(null);
if (realm != null) {
context.putValue(realm);
}
return realm != null;
}
@Override
public TagEntity getTagByTagTypeAndDisplayName(String tagTypeCode, String displayName)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<TagEntity> criteria = builder.createQuery(TagEntity.class);
// The criteria root is the tag entity.
Root<TagEntity> tagEntityRoot = criteria.from(TagEntity.class);
// Join on the other tables we can filter on.
Join<TagEntity, TagTypeEntity> tagTypeEntityJoin = tagEntityRoot.join(TagEntity_.tagType);
// Create the standard restrictions (i.e. the standard where clauses).
List<Predicate> predicates = new ArrayList<>();
predicates.add(builder.equal(builder.upper(tagTypeEntityJoin.get(TagTypeEntity_.code)), tagTypeCode.toUpperCase()));
predicates.add(builder.equal(builder.upper(tagEntityRoot.get(TagEntity_.displayName)), displayName.toUpperCase()));
// Add all clauses to the query.
criteria.select(tagEntityRoot).where(builder.and(predicates.toArray(new Predicate[predicates.size()])));
return executeSingleResultQuery(criteria,
String.format("Found more than one tag with parameters {tagType=\"%s\", displayName=\"%s\"}.", tagTypeCode, displayName));
}
@Override
public List<CategoryOptionGroup> getCategoryOptionGroups( CategoryOptionGroupSet groupSet )
{
CriteriaBuilder builder = getCriteriaBuilder();
JpaQueryParameters<CategoryOptionGroup> parameters = newJpaParameters()
.addPredicates( getSharingPredicates( builder ) )
.addPredicate( root -> {
Join<Object, Object> groupSets = root.join( "groupSets" );
return builder.or( builder.equal( groupSets.get( "id" ) , groupSet.getId() ),
builder.isNull( groupSets.get( "id" ) ) );
});
return getList( builder, parameters );
}
@Override
public CustomDdlEntity getCustomDdlByKey(CustomDdlKey customDdlKey)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<CustomDdlEntity> criteria = builder.createQuery(CustomDdlEntity.class);
// The criteria root is the custom DDL.
Root<CustomDdlEntity> customDdlEntity = criteria.from(CustomDdlEntity.class);
// Join to the other tables we can filter on.
Join<CustomDdlEntity, BusinessObjectFormatEntity> businessObjectFormatEntity = customDdlEntity.join(CustomDdlEntity_.businessObjectFormat);
Join<BusinessObjectFormatEntity, BusinessObjectDefinitionEntity> businessObjectDefinitionEntity = businessObjectFormatEntity.join(
BusinessObjectFormatEntity_.businessObjectDefinition);
Join<BusinessObjectFormatEntity, FileTypeEntity> fileTypeEntity = businessObjectFormatEntity.join(BusinessObjectFormatEntity_.fileType);
Join<BusinessObjectDefinitionEntity, NamespaceEntity> namespaceEntity = businessObjectDefinitionEntity.join(BusinessObjectDefinitionEntity_.namespace);
// Create the standard restrictions (i.e. the standard where clauses).
Predicate queryRestriction = builder.equal(builder.upper(namespaceEntity.get(NamespaceEntity_.code)), customDdlKey.getNamespace().toUpperCase());
queryRestriction = builder.and(queryRestriction, builder.equal(builder.upper(businessObjectDefinitionEntity.get(BusinessObjectDefinitionEntity_.name)),
customDdlKey.getBusinessObjectDefinitionName().toUpperCase()));
queryRestriction = builder.and(queryRestriction, builder.equal(builder.upper(businessObjectFormatEntity.get(BusinessObjectFormatEntity_.usage)),
customDdlKey.getBusinessObjectFormatUsage().toUpperCase()));
queryRestriction = builder.and(queryRestriction, builder.equal(builder.upper(fileTypeEntity.get(FileTypeEntity_.code)), customDdlKey
.getBusinessObjectFormatFileType().toUpperCase()));
queryRestriction = builder.and(queryRestriction, builder.equal(businessObjectFormatEntity.get(BusinessObjectFormatEntity_.businessObjectFormatVersion),
customDdlKey.getBusinessObjectFormatVersion()));
queryRestriction = builder.and(queryRestriction, builder.equal(builder.upper(customDdlEntity.get(CustomDdlEntity_.customDdlName)), customDdlKey
.getCustomDdlName().toUpperCase()));
// Add select and where clauses.
criteria.select(customDdlEntity).where(queryRestriction);
return executeSingleResultQuery(criteria, String.format("Found more than one custom DDL instance with parameters {businessObjectDefinitionName=\"%s\","
+ " businessObjectFormatUsage=\"%s\", businessObjectFormatFileType=\"%s\", businessObjectFormatVersion=\"%d\", customDdlName=\"%s\"}.", customDdlKey
.getBusinessObjectDefinitionName(), customDdlKey.getBusinessObjectFormatUsage(), customDdlKey.getBusinessObjectFormatFileType(), customDdlKey
.getBusinessObjectFormatVersion(), customDdlKey.getCustomDdlName()));
}
@Test
@Transactional
public void testCountCriteria() {
EntityManager em = bookDao.getEntityManager();
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Book> criteria = cb.createQuery(Book.class);
Root<Book> root = criteria.from(Book.class);
Join<Book, Author> join = root.join("author");
criteria.where(join.isNotNull());
CriteriaQuery<Long> countCriteria = JpaUtils.countCriteria(em, criteria);
Long result = em.createQuery(countCriteria).getSingleResult();
log.debug("Count: " + result);
}
@Override
public GlobalAttributeDefinitionEntity getGlobalAttributeDefinitionByKey(GlobalAttributeDefinitionKey globalAttributeDefinitionKey)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<GlobalAttributeDefinitionEntity> criteria = builder.createQuery(GlobalAttributeDefinitionEntity.class);
// The criteria root is the global attribute definition entity.
Root<GlobalAttributeDefinitionEntity> globalAttributeDefinitionEntityRoot = criteria.from(GlobalAttributeDefinitionEntity.class);
//Join on the other tables that we filter on
Join<GlobalAttributeDefinitionEntity, GlobalAttributeDefinitionLevelEntity> globalAttributeDefinitionLevelEntityJoin =
globalAttributeDefinitionEntityRoot.join(GlobalAttributeDefinitionEntity_.globalAttributeDefinitionLevel);
// Create the standard restrictions (i.e. the standard where clauses).
List<Predicate> predicates = new ArrayList<>();
predicates.add(builder
.equal(builder.upper(globalAttributeDefinitionLevelEntityJoin.get(GlobalAttributeDefinitionLevelEntity_.globalAttributeDefinitionLevel)),
globalAttributeDefinitionKey.getGlobalAttributeDefinitionLevel().toUpperCase()));
predicates.add(builder.equal(builder.upper(globalAttributeDefinitionEntityRoot.get(GlobalAttributeDefinitionEntity_.globalAttributeDefinitionName)),
globalAttributeDefinitionKey.getGlobalAttributeDefinitionName().toUpperCase()));
// Add all clauses to the query.
criteria.select(globalAttributeDefinitionEntityRoot).where(builder.and(predicates.toArray(new Predicate[predicates.size()])));
return executeSingleResultQuery(criteria, String.format(
"Found more than one global attribute definition with parameters {globalAttributeDefinitionLevel=\"%s\", globalAttributeDefinitionLevel=\"%s\"}.",
globalAttributeDefinitionKey.getGlobalAttributeDefinitionLevel(), globalAttributeDefinitionKey.getGlobalAttributeDefinitionName()));
}
private CriteriaQuery<Issue> buildCriteriaQuery(@Nullable Project project,
Session session, EntityQuery<Issue> issueQuery) {
CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Issue> query = builder.createQuery(Issue.class);
Root<Issue> root = query.from(Issue.class);
query.where(getPredicates(project, issueQuery.getCriteria(), root, builder));
List<javax.persistence.criteria.Order> orders = new ArrayList<>();
for (EntitySort sort: issueQuery.getSorts()) {
if (Issue.ORDER_FIELDS.containsKey(sort.getField())) {
if (sort.getDirection() == Direction.ASCENDING)
orders.add(builder.asc(IssueQuery.getPath(root, Issue.ORDER_FIELDS.get(sort.getField()))));
else
orders.add(builder.desc(IssueQuery.getPath(root, Issue.ORDER_FIELDS.get(sort.getField()))));
} else {
Join<Issue, IssueField> join = root.join(Issue.PROP_FIELDS, JoinType.LEFT);
join.on(builder.equal(join.get(IssueField.PROP_NAME), sort.getField()));
if (sort.getDirection() == Direction.ASCENDING)
orders.add(builder.asc(join.get(IssueField.PROP_ORDINAL)));
else
orders.add(builder.desc(join.get(IssueField.PROP_ORDINAL)));
}
}
if (orders.isEmpty()) {
orders.add(builder.desc(IssueQuery.getPath(root, Issue.PROP_LAST_UPDATE + "." + LastUpdate.PROP_DATE)));
}
query.orderBy(orders);
return query;
}
@Override
public BusinessObjectDataNotificationRegistrationEntity getBusinessObjectDataNotificationRegistrationByAltKey(NotificationRegistrationKey key)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<BusinessObjectDataNotificationRegistrationEntity> criteria = builder.createQuery(BusinessObjectDataNotificationRegistrationEntity.class);
// The criteria root is the business object data notification registration entity.
Root<BusinessObjectDataNotificationRegistrationEntity> businessObjectDataNotificationEntity =
criteria.from(BusinessObjectDataNotificationRegistrationEntity.class);
// Join to the other tables we can filter on.
Join<BusinessObjectDataNotificationRegistrationEntity, NamespaceEntity> namespaceEntity =
businessObjectDataNotificationEntity.join(BusinessObjectDataNotificationRegistrationEntity_.namespace);
// Create the standard restrictions (i.e. the standard where clauses).
Predicate queryRestriction = builder.equal(builder.upper(namespaceEntity.get(NamespaceEntity_.code)), key.getNamespace().toUpperCase());
queryRestriction = builder.and(queryRestriction, builder
.equal(builder.upper(businessObjectDataNotificationEntity.get(BusinessObjectDataNotificationRegistrationEntity_.name)),
key.getNotificationName().toUpperCase()));
criteria.select(businessObjectDataNotificationEntity).where(queryRestriction);
return executeSingleResultQuery(criteria, String
.format("Found more than one business object data notification registration with with parameters {namespace=\"%s\", notificationName=\"%s\"}.",
key.getNamespace(), key.getNotificationName()));
}
private Path<?> getExistingJoinProperty(From<?, ?> element, String prop) {
final Set<?> joins = element.getJoins();
for (Object object : joins) {
Join<?, ?> join = (Join<?, ?>) object;
if (join.getAttribute().getName().equals(prop)) {
return join;
}
}
return null;
}
@Override
public Page<TargetWithActionStatus> findAllTargetsOfRolloutGroupWithActionStatus(final Pageable pageRequest,
final long rolloutGroupId) {
throwExceptionIfRolloutGroupDoesNotExist(rolloutGroupId);
final CriteriaBuilder cb = entityManager.getCriteriaBuilder();
final CriteriaQuery<Object[]> query = cb.createQuery(Object[].class);
final CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
final Root<RolloutTargetGroup> targetRoot = query.distinct(true).from(RolloutTargetGroup.class);
final Join<RolloutTargetGroup, JpaTarget> targetJoin = targetRoot.join(RolloutTargetGroup_.target);
final ListJoin<RolloutTargetGroup, JpaAction> actionJoin = targetRoot.join(RolloutTargetGroup_.actions,
JoinType.LEFT);
final Root<RolloutTargetGroup> countQueryFrom = countQuery.distinct(true).from(RolloutTargetGroup.class);
countQueryFrom.join(RolloutTargetGroup_.target);
countQueryFrom.join(RolloutTargetGroup_.actions, JoinType.LEFT);
countQuery.select(cb.count(countQueryFrom)).where(cb
.equal(countQueryFrom.get(RolloutTargetGroup_.rolloutGroup).get(JpaRolloutGroup_.id), rolloutGroupId));
final Long totalCount = entityManager.createQuery(countQuery).getSingleResult();
final CriteriaQuery<Object[]> multiselect = query.multiselect(targetJoin, actionJoin.get(JpaAction_.status))
.where(cb.equal(targetRoot.get(RolloutTargetGroup_.rolloutGroup).get(JpaRolloutGroup_.id),
rolloutGroupId));
final List<TargetWithActionStatus> targetWithActionStatus = entityManager.createQuery(multiselect)
.setFirstResult((int) pageRequest.getOffset()).setMaxResults(pageRequest.getPageSize()).getResultList()
.stream().map(o -> new TargetWithActionStatus((Target) o[0], (Action.Status) o[1]))
.collect(Collectors.toList());
return new PageImpl<>(targetWithActionStatus, pageRequest, totalCount);
}
@Override
public BusinessObjectFormatEntity getBusinessObjectFormatByAltKey(BusinessObjectFormatKey businessObjectFormatKey)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<BusinessObjectFormatEntity> criteria = builder.createQuery(BusinessObjectFormatEntity.class);
// The criteria root is the business object format.
Root<BusinessObjectFormatEntity> businessObjectFormatEntity = criteria.from(BusinessObjectFormatEntity.class);
// Join to the other tables we can filter on.
Join<BusinessObjectFormatEntity, FileTypeEntity> fileTypeEntity = businessObjectFormatEntity.join(BusinessObjectFormatEntity_.fileType);
Join<BusinessObjectFormatEntity, BusinessObjectDefinitionEntity> businessObjectDefinitionEntity =
businessObjectFormatEntity.join(BusinessObjectFormatEntity_.businessObjectDefinition);
// Create the standard restrictions (i.e. the standard where clauses).
// Please note that we specify not to ignore the business object format version.
Predicate queryRestriction =
getQueryRestriction(builder, businessObjectFormatEntity, fileTypeEntity, businessObjectDefinitionEntity, businessObjectFormatKey, false);
// If a business format version was not specified, use the latest one.
if (businessObjectFormatKey.getBusinessObjectFormatVersion() == null)
{
queryRestriction = builder.and(queryRestriction, builder.isTrue(businessObjectFormatEntity.get(BusinessObjectFormatEntity_.latestVersion)));
}
criteria.select(businessObjectFormatEntity).where(queryRestriction);
return executeSingleResultQuery(criteria, String.format("Found more than one business object format instance with parameters " +
"{namespace=\"%s\", businessObjectDefinitionName=\"%s\", businessObjectFormatUsage=\"%s\", businessObjectFormatFileType=\"%s\", " +
"businessObjectFormatVersion=\"%d\"}.", businessObjectFormatKey.getNamespace(), businessObjectFormatKey.getBusinessObjectDefinitionName(),
businessObjectFormatKey.getBusinessObjectFormatUsage(), businessObjectFormatKey.getBusinessObjectFormatFileType(),
businessObjectFormatKey.getBusinessObjectFormatVersion()));
}
@Override
public List<StorageUnitEntity> getS3StorageUnitsToRestore(int maxResult)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<StorageUnitEntity> criteria = builder.createQuery(StorageUnitEntity.class);
// The criteria root is the storage unit.
Root<StorageUnitEntity> storageUnitEntityRoot = criteria.from(StorageUnitEntity.class);
// Join to the other tables we can filter on.
Join<StorageUnitEntity, StorageEntity> storageEntityJoin = storageUnitEntityRoot.join(StorageUnitEntity_.storage);
Join<StorageEntity, StoragePlatformEntity> storagePlatformEntityJoin = storageEntityJoin.join(StorageEntity_.storagePlatform);
Join<StorageUnitEntity, StorageUnitStatusEntity> storageUnitStatusEntityJoin = storageUnitEntityRoot.join(StorageUnitEntity_.status);
// Create the standard restrictions (i.e. the standard where clauses).
List<Predicate> predicates = new ArrayList<>();
predicates.add(builder.equal(storagePlatformEntityJoin.get(StoragePlatformEntity_.name), StoragePlatformEntity.S3));
predicates.add(builder.equal(storageUnitStatusEntityJoin.get(StorageUnitStatusEntity_.code), StorageUnitStatusEntity.RESTORING));
// Order the results by storage unit updated on timestamp.
Order orderBy = builder.asc(storageUnitEntityRoot.get(StorageUnitEntity_.updatedOn));
// Add the clauses for the query.
criteria.select(storageUnitEntityRoot).where(builder.and(predicates.toArray(new Predicate[predicates.size()]))).orderBy(orderBy);
// Execute the query and return the results.
return entityManager.createQuery(criteria).setMaxResults(maxResult).getResultList();
}
@Override
public Predicate getPredicate(Root<PullRequest> root, CriteriaBuilder builder) {
if (User.get() != null) {
Join<?, ?> join = root.join(PullRequest.PROP_ASSIGNMENTS, JoinType.LEFT);
Path<?> userPath = EntityQuery.getPath(join, PullRequestAssignment.PROP_USER);
join.on(builder.equal(userPath, User.get()));
return join.isNotNull();
} else {
throw new OneException("Please login to perform this query");
}
}
private Join joinList(From path)
{
if (joinType == null)
{
return path.join(list);
}
return path.join(list, joinType);
}
@Override
public SecurityRoleFunctionEntity getSecurityRoleFunctionByKey(SecurityRoleFunctionKey securityRoleFunctionKey)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<SecurityRoleFunctionEntity> criteria = builder.createQuery(SecurityRoleFunctionEntity.class);
// The criteria root is the security role to function mapping.
Root<SecurityRoleFunctionEntity> securityRoleFunctionEntityRoot = criteria.from(SecurityRoleFunctionEntity.class);
// Join on the other tables.
Join<SecurityRoleFunctionEntity, SecurityRoleEntity> securityRoleEntityJoin =
securityRoleFunctionEntityRoot.join(SecurityRoleFunctionEntity_.securityRole);
Join<SecurityRoleFunctionEntity, SecurityFunctionEntity> securityFunctionEntityJoin =
securityRoleFunctionEntityRoot.join(SecurityRoleFunctionEntity_.securityFunction);
// Create the standard restrictions (i.e. the standard where clauses).
List<Predicate> predicates = new ArrayList<>();
predicates.add(
builder.equal(builder.upper(securityRoleEntityJoin.get(SecurityRoleEntity_.code)), securityRoleFunctionKey.getSecurityRoleName().toUpperCase()));
predicates.add(builder.equal(builder.upper(securityFunctionEntityJoin.get(SecurityFunctionEntity_.code)),
securityRoleFunctionKey.getSecurityFunctionName().toUpperCase()));
// Add all clauses to the query.
criteria.select(securityRoleFunctionEntityRoot).where(builder.and(predicates.toArray(new Predicate[predicates.size()])));
// Execute the query and return the result.
return executeSingleResultQuery(criteria, String
.format("Found more than one security role to function mapping with parameters {securityRoleName=\"%s\", securityFunctionName=\"%s\"}.",
securityRoleFunctionKey.getSecurityRoleName(), securityRoleFunctionKey.getSecurityFunctionName()));
}
@Override
public Predicate getPredicate(Root<PullRequest> root, CriteriaBuilder builder) {
if (User.get() != null) {
Join<?, ?> join = root.join(PullRequest.PROP_REVIEWS, JoinType.LEFT);
Path<?> userPath = EntityQuery.getPath(join, PullRequestReview.PROP_USER);
Path<?> approvedPath = EntityQuery.getPath(join, PullRequestReview.PROP_RESULT + "." + ReviewResult.PROP_APPROVED);
join.on(builder.and(
builder.equal(userPath, User.get()),
builder.equal(approvedPath, true)));
return join.isNotNull();
} else {
throw new OneException("Please login to perform this query");
}
}
@Override
public Predicate getPredicate(Root<PullRequest> root, CriteriaBuilder builder) {
Join<?, ?> join = root
.join(PullRequest.PROP_VERIFICATIONS, JoinType.LEFT)
.join(PullRequestVerification.PROP_BUILD, JoinType.INNER);
Path<?> status = join.get(Build.STATUS);
join.on(builder.or(
builder.equal(status, Build.Status.FAILED),
builder.equal(status, Build.Status.CANCELLED),
builder.equal(status, Build.Status.TIMED_OUT)));
return join.isNotNull();
}
@Override
public Predicate getPredicate(Root<PullRequest> root, CriteriaBuilder builder) {
if (User.get() != null) {
Join<?, ?> join = root.join(PullRequest.PROP_REVIEWS, JoinType.LEFT);
Path<?> userPath = EntityQuery.getPath(join, PullRequestReview.PROP_USER);
Path<?> approvedPath = EntityQuery.getPath(join, PullRequestReview.PROP_RESULT + "." + ReviewResult.PROP_APPROVED);
join.on(builder.and(
builder.equal(userPath, User.get()),
builder.equal(approvedPath, false)));
return join.isNotNull();
} else {
throw new OneException("Please login to perform this query");
}
}
private <T> Join<T, ?> getJoin(String name, Set<Join<T, ?>> joins) {
for (Join<T, ?> join : joins) {
if (join.getAttribute().getName().equals(name)) {
return join;
}
}
return null;
}
@Override
public List<StorageUnitEntity> getLatestVersionStorageUnitsByStoragePlatformAndFileType(String storagePlatform, String businessObjectFormatFileType)
{
// Create the criteria builder and the criteria.
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<StorageUnitEntity> criteria = builder.createQuery(StorageUnitEntity.class);
// The criteria root is the storage unit.
Root<StorageUnitEntity> storageUnitEntityRoot = criteria.from(StorageUnitEntity.class);
// Join to the other tables we can filter on.
Join<StorageUnitEntity, StorageEntity> storageEntityJoin = storageUnitEntityRoot.join(StorageUnitEntity_.storage);
Join<StorageEntity, StoragePlatformEntity> storagePlatformEntityJoin = storageEntityJoin.join(StorageEntity_.storagePlatform);
Join<StorageUnitEntity, BusinessObjectDataEntity> businessObjectDataEntityJoin = storageUnitEntityRoot.join(StorageUnitEntity_.businessObjectData);
Join<BusinessObjectDataEntity, BusinessObjectFormatEntity> businessObjectFormatEntityJoin =
businessObjectDataEntityJoin.join(BusinessObjectDataEntity_.businessObjectFormat);
Join<BusinessObjectFormatEntity, FileTypeEntity> fileTypeEntityJoin = businessObjectFormatEntityJoin.join(BusinessObjectFormatEntity_.fileType);
// Create the standard restrictions (i.e. the standard where clauses).
List<Predicate> predicates = new ArrayList<>();
predicates.add(builder.equal(builder.upper(storagePlatformEntityJoin.get(StoragePlatformEntity_.name)), storagePlatform.toUpperCase()));
predicates.add(builder.equal(builder.upper(fileTypeEntityJoin.get(FileTypeEntity_.code)), businessObjectFormatFileType.toUpperCase()));
predicates.add(builder.isTrue(businessObjectFormatEntityJoin.get(BusinessObjectFormatEntity_.latestVersion)));
predicates.add(builder.isTrue(businessObjectDataEntityJoin.get(BusinessObjectDataEntity_.latestVersion)));
// Order by storage unit created on timestamp.
Order orderBy = builder.asc(storageUnitEntityRoot.get(StorageUnitEntity_.createdOn));
// Add the clauses for the query.
criteria.select(storageUnitEntityRoot).where(builder.and(predicates.toArray(new Predicate[predicates.size()]))).orderBy(orderBy);
// Execute the query and return the results.
return entityManager.createQuery(criteria).getResultList();
}
@Override
protected Predicate getValuePredicate(Join<?, ?> field, CriteriaBuilder builder) {
Path<Integer> attribute = field.get(IssueField.PROP_ORDINAL);
if (operator == IssueQueryLexer.Is)
return builder.equal(attribute, value);
else if (operator == IssueQueryLexer.IsGreaterThan)
return builder.greaterThan(attribute, value);
else
return builder.lessThan(attribute, value);
}
@Override
public Predicate getPredicate(Root<Issue> root, CriteriaBuilder builder) {
Join<?, ?> join = root.join(Issue.PROP_COMMENTS, JoinType.LEFT);
Path<String> attribute = join.get(IssueComment.PATH_CONTENT);
join.on(builder.like(builder.lower(attribute), "%" + value.toLowerCase() + "%"));
return join.isNotNull();
}