@Override public <T> SubqueryInitiator<T> applySubquery(RestrictionBuilder<T> rb) { return rb.eq(); }
private Map<String, List<String>> delete(String bucketId, List<String> bucketObjectNames) { if (bucketObjectNames == null || bucketObjectNames.isEmpty()) { return Collections.emptyMap(); } Bucket bucket = em.find(Bucket.class, bucketId, LockModeType.PESSIMISTIC_WRITE); // TODO: check access rights? if (bucket == null) { throw new BucketNotFoundException("Bucket '" + bucketId + "' does not exist!"); } List<BucketObjectVersion> bucketObjectVersions = cbf.create(em, BucketObjectVersion.class) .fetch("storage") .fetch("bucketObject") .where("id.bucketId").eq(bucketId) .where("state").eq(BucketObjectState.CREATED) .where("id.bucketObjectName").in(bucketObjectNames) .getQuery() .setLockMode(LockModeType.PESSIMISTIC_WRITE) .getResultList(); if (bucketObjectVersions.size() == 0) { return Collections.emptyMap(); } return deleteBucketObjectVersions(bucket, bucketObjectVersions, true); }
private void prepareWhere(CriteriaBuilder<?> cb, E example, List<Property<Object>> properties, boolean useLikeOperator) { Iterator<Property<Object>> iterator = properties.iterator(); while (iterator.hasNext()) { Property<Object> property = iterator.next(); String name = property.getName(); if (useLikeOperator && property.getJavaClass().getName().equals(String.class.getName())) { cb.where(name).like(false).value(property.getValue(example)).noEscape(); } else { cb.where(name).eq(property.getValue(example)); } } }
@Override public Bucket findByName(String bucketName) { try { return cbf.create(em, Bucket.class) .where("id").eq(bucketName) .where("deleted").eqExpression("false") .getSingleResult(); } catch (NoResultException ex) { return null; } }
.where("id").eq(bucketName) .where("deleted").eqExpression("false"); cb.where("objects.id.name").like().value(prefix.replaceAll("%", "\\%") + "%").escape('\\'); cb.where("objects.id.name").gt(marker);
@Override public <T> T findByName(String weblinkGroupName, String prefix, Integer limit, String marker, EntityViewSetting<T, ? extends QueryBuilder<T,?>> setting) { if (limit == null) { limit = 1000; } else if (limit > 1000) { throw new IllegalArgumentException("Limit may not exceed 1000!"); } try { CriteriaBuilder<WeblinkGroup> cb = cbf.create(em, WeblinkGroup.class) .where("id").eq(weblinkGroupName); if (prefix != null && !prefix.isEmpty()) { cb.where("links.id.name").like().value(prefix.replaceAll("%", "\\%") + "%").escape('\\'); } if (marker != null && !marker.isEmpty()) { cb.where("links.id.name").gt(marker); } // TODO: implement constraint and marker in query and also for passing into entity views setting.addOptionalParameter("prefix", prefix); setting.addOptionalParameter("constraint", limit); setting.addOptionalParameter("marker", marker); cb.setMaxResults(limit); return evm.applySetting(setting, cb).getSingleResult(); } catch (NoResultException ex) { return null; } }
@Override public <T> T findByIdForDispatch(WeblinkId weblinkId, EntityViewSetting<T, ? extends QueryBuilder<T,?>> setting) { try { CriteriaBuilder<Weblink> cb = cbf.create(em, Weblink.class) .where("id").eq(weblinkId) .whereOr() .where("expirationTime").isNull() .where("expirationTime").gtExpression("CURRENT_TIMESTAMP") .endOr(); return evm.applySetting(setting, cb).getSingleResult(); } catch (NoResultException ex) { return null; } }
protected Collection<Object> appendRemoveSpecific(UpdateContext context, DeleteCriteriaBuilder<?> deleteCb, FusedCollectionActions fusedCollectionActions) { deleteCb.where("e." + getMapping()).in(fusedCollectionActions.getRemoved(context)); return new HashSet<>(fusedCollectionActions.getRemoved()); }
public void addIdParamPredicate(FullQueryBuilder<?, ?> criteriaBuilder) { if (viewRootExpression != null && viewRootExpression.charAt(0) != ':') { if (viewRootParamName != null) { criteriaBuilder.where(viewRootExpression).eqExpression(":" + viewRootParamName); } else { criteriaBuilder.where(viewRootExpression + '.' + viewRootIdPath).eqExpression(":" + getIdParamName()); } } }
@Override public <T> T apply(RestrictionBuilder<T> rb) { return rb.like().value(value).noEscape(); } }
updateCb.setExpression("INDEX(" + mapping + ")", "INDEX(" + mapping + ") + :offset"); updateCb.setWhereExpression(ownerIdWhereFragment); updateCb.where("INDEX(" + mapping + ")").geExpression(":minIdx"); updateCb.where("INDEX(" + mapping + ")").ltExpression(":maxIdx"); Query query = updateCb.getQuery(); ownerIdFlusher.flushQuery(context, null, query, ownerView, view, ownerIdFlusher.getViewAttributeAccessor().getValue(ownerView), null); updateCb.setExpression(mapping, ":element"); updateCb.setWhereExpression(ownerIdWhereFragment); updateCb.where("INDEX(" + mapping + ")").eqExpression(":idx"); Query query = updateCb.getQuery();
@Override public <T> SubqueryInitiator<T> applySubquery(RestrictionBuilder<T> rb) { return rb.gt(); } }
@Override public <T> List<T> findByAccountIdAndStorageName(long accountId, String storageName, EntityViewSetting<T, ? extends QueryBuilder<T,?>> setting) { CriteriaBuilder<Bucket> cb = cbf.create(em, Bucket.class) .from(Bucket.class) .where("owner.id").eq(accountId) .where("deleted").eqExpression("false") .where("storage.id.name").eq(storageName); return evm.applySetting(setting, cb).getResultList(); }
@Override public Iterable<V> findAll(Iterable<ID> idIterable) { Assert.notNull(idIterable, ID_MUST_NOT_BE_NULL); List<ID> idList = new ArrayList<>(); for (ID id : idIterable) { idList.add(id); } CriteriaBuilder<?> cb = cbf.create(entityManager, getDomainClass()) .where(getIdAttribute()).in(idList); TypedQuery<V> findAllByIdsQuery = evm.applySetting(setting, cb).getQuery(); applyRepositoryMethodMetadata(findAllByIdsQuery); return findAllByIdsQuery.getResultList(); }
@Override public void addBatchPredicate(FullQueryBuilder<?, ?> criteriaBuilder) { if (viewRootExpression == CORRELATION_EMBEDDING_VIEW_ALIAS) { criteriaBuilder.innerJoinOn(originalViewRootExpression, viewRootEntityType, CORRELATION_EMBEDDING_VIEW_ALIAS) .on(originalViewRootExpression + "." + viewRootIdPath).eqExpression(CORRELATION_EMBEDDING_VIEW_ALIAS + "." + viewRootIdPath) .end(); } }
@Override public <T> T apply(RestrictionBuilder<T> rb) { return rb.like(false).value(value).noEscape(); } }
@Override public <T> T applyRestriction(RestrictionBuilder<T> rb, Object value) { return rb.gt(value); }
@Override public <T> T applyRestriction(RestrictionBuilder<T> rb, Object value) { return rb.eq(value); }
@Override public <T> List<T> findByAccountId(long accountId, EntityViewSetting<T, ? extends QueryBuilder<T,?>> setting) { CriteriaBuilder<Bucket> cb = cbf.create(em, Bucket.class) .where("owner.id").eq(accountId) .where("deleted").eqExpression("false"); return evm.applySetting(setting, cb).getResultList(); }