@Override public Account findById(long accountId) { try { return cbf.create(em, Account.class) .where("id").eq(accountId) .getSingleResult(); } catch (NoResultException ex) { return null; } }
@Override public Storage findByBucketId(String bucketId) { if (bucketId == null) { return null; } try { return cbf.create(em, Storage.class) .from(Bucket.class) .where("id").eq(bucketId) .select("storage") .getSingleResult(); } catch (NoResultException ex) { return null; } }
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); }
@Override public StorageQuotaModel findById(String id) { if (id == null) { return null; } try { return cbf.create(em, StorageQuotaModel.class) .fetch("plans") .where("id").eq(id) .getSingleResult(); } catch (NoResultException ex) { return null; } }
public boolean exists(ID id) { Assert.notNull(id, ID_MUST_NOT_BE_NULL); TypedQuery<Object> existsQuery = cbf.create(entityManager, Object.class) .from(getDomainClass()) // Empty string because SQLServer can't interpret a number properly when using TOP clause .select("''") .where(idAttributeName).eq(id) .setMaxResults(1) .getQuery(); applyRepositoryMethodMetadata(existsQuery, true); try { return !existsQuery.getResultList().isEmpty(); } catch (NoResultException e) { return false; } }
public List<PostFlushDeleter> removeByOwnerId(UpdateContext context, Object ownerId) { EntityViewManagerImpl evm = context.getEntityViewManager(); List<Object> elementIds = (List<Object>) evm.getCriteriaBuilderFactory().create(context.getEntityManager(), parentEntityClass, "e") .where(parentIdAttributeName).eq(ownerId) .select("e." + attributeName + "." + childIdAttributeName) .getResultList(); if (!elementIds.isEmpty()) { // We must always delete this, otherwise we might get a constraint violation because of the cascading delete DeleteCriteriaBuilder<?> cb = evm.getCriteriaBuilderFactory().deleteCollection(context.getEntityManager(), parentEntityClass, "e", attributeName); cb.where(parentIdAttributeName).eq(ownerId); cb.executeUpdate(); } return Collections.<PostFlushDeleter>singletonList(new PostFlushInverseCollectionElementByIdDeleter(deleter, elementIds)); }
public <T> List<T> getCatHierarchy(Integer catId, EntityViewSetting<T, CriteriaBuilder<T>> setting) { CriteriaBuilder<Tuple> cb = cbf.create(emHolder.getEntityManager(), Tuple.class) .withRecursive(CatHierarchyCTE.class) .from(Cat.class) .bind("id").select("id") .bind("motherId").select("mother.id") .bind("fatherId").select("father.id") .bind("generation").select("0") .where("id").eqExpression(catId.toString()) .unionAll() .from(Cat.class, "cat") .from(CatHierarchyCTE.class, "cte") .bind("id").select("cat.id") .bind("motherId").select("cat.mother.id") .bind("fatherId").select("cat.father.id") .bind("generation").select("cte.generation + 1") .whereOr() .where("cat.id").eqExpression("cte.motherId") .where("cat.id").eqExpression("cte.fatherId") .endOr() .end() .from(Cat.class, "cat") .innerJoinOn(CatHierarchyCTE.class, "cte").on("cte.id").eqExpression("cat.id").end() .orderByAsc("cte.generation"); 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(); }
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)); } } }
CriteriaBuilder<?> cb = createCriteriaBuilder(); if (selectExpression != null) { cb.select(selectExpression); cb.orderByAsc(idAttribute()); cb.fetch(fetches); if (viewClass() == null) { if (start > 0 || max > 0) { query = (TypedQuery<V>) cb.page(start, max).getQuery(); } else { query = (TypedQuery<V>) cb.getQuery();
@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 V findBy(PK pk) { CriteriaBuilder<E> cb = createCriteriaBuilder(); List<V> result = context.getEntityViewManager().applySetting( createSetting(), cb.where(idAttribute()).eq(pk) ).getResultList(); return result.isEmpty() ? null : result.get(0); }
private String createQueryString(EntityViewManagerImpl evm, EntityType<?> entityType, Map<String, Map<?, ?>> fetchGraph) { CriteriaBuilderFactory cbf = evm.getCriteriaBuilderFactory(); EntityManagerFactory emf = cbf.getService(EntityManagerFactory.class); EntityManager em = emf.createEntityManager(); try { String[] paths = flatten(fetchGraph); if (paths.length == 0) { return null; } else { return cbf.create(em, entityClass) .fetch(paths) .where(JpaMetamodelUtils.getSingleIdAttribute(entityType).getName()).eqExpression(":id") .getQueryString(); } } finally { em.close(); } }
cb.fetch(fetches); if (entityViewClass == null) { if (pageable == null) { query = (TypedQuery<V>) cb.getQuery(); } else { PaginatedCriteriaBuilder<S> paginatedCriteriaBuilder; if (pageable instanceof KeysetPageable) { paginatedCriteriaBuilder = cb.page(((KeysetPageable) pageable).getKeysetPage(), getOffset(pageable), pageable.getPageSize()); } else { paginatedCriteriaBuilder = cb.page(getOffset(pageable), pageable.getPageSize()); if (pageable == null) { EntityViewSetting<V, CriteriaBuilder<V>> setting = EntityViewSetting.create(entityViewClass); query = evm.applySetting(setting, cb).getQuery(); } else { EntityViewSetting<V, PaginatedCriteriaBuilder<V>> setting = EntityViewSetting.create(entityViewClass, getOffset(pageable), pageable.getPageSize());
public void apply(CriteriaBuilder<?> cb) { if (methodPrefix.isDelete()) { throw new UnsupportedOperationException("Delete queries not supported in entity view repositories"); } else { cb.from(entityClass); } if (whereExpression != null) { cb.setWhereExpression(whereExpression); } for (OrderByQueryAttribute orderByAttribute : orderByAttributes) { orderByAttribute.buildQuery(cb); } }
@Override public List<V> findAll(int start, int max) { CriteriaBuilder<E> cb = createCriteriaBuilder().orderByAsc(idAttribute()); String[] fetches = getFetches(); if (fetches.length != 0) { cb.fetch(fetches); } TypedQuery<V> query; if (viewClass() == null) { query = (TypedQuery<V>) cb.getQuery(); } else { EntityViewSetting<V, PaginatedCriteriaBuilder<V>> setting = EntityViewSetting.create(viewClass(), start, max); query = applySetting(setting, cb) .getQuery(); } applyQueryHints(query, fetches.length == 0); return query.getResultList(); }
private void transformViewMacroAware(List<Object[]> tuples, FixedArrayList correlationParams, int tupleOffset, String correlationRoot, CorrelatedSubqueryViewRootJpqlMacro macro, BatchCorrelationMode correlationMode, ManagedViewType<?> viewType, int viewIndex) { EntityManager em = criteriaBuilder.getEntityManager(); macro = BatchCorrelationMode.VIEW_ROOTS == correlationMode ? viewRootJpqlMacro : embeddingViewJpqlMacro; correlator.finish(criteriaBuilder, entityViewConfiguration, tupleOffset, correlationRoot, embeddingViewJpqlMacro); criteriaBuilder.select(correlationSelectExpression); query = criteriaBuilder.getQuery(); macro = BatchCorrelationMode.VIEW_ROOTS == correlationMode ? viewRootJpqlMacro : embeddingViewJpqlMacro; correlator.finish(criteriaBuilder, entityViewConfiguration, tupleOffset, correlationRoot, embeddingViewJpqlMacro); criteriaBuilder.select(correlationSelectExpression); query = criteriaBuilder.getQuery();
@Override public List<V> findAll() { CriteriaBuilder<E> cb = createCriteriaBuilder(); String[] fetches = getFetches(); if (fetches.length != 0) { cb.fetch(fetches); } TypedQuery<V> query; if (viewClass() == null) { query = (TypedQuery<V>) cb.getQuery(); } else { query = applySetting( createSetting(), cb ).getQuery(); } applyQueryHints(query, fetches.length == 0); return query.getResultList(); }
protected TypedQuery<?> createQuery0(CriteriaQuery<?> criteriaQuery, Object[] values) { processSpecification(criteriaQuery, values); com.blazebit.persistence.CriteriaBuilder<?> cb = ((BlazeCriteriaQuery<?>) criteriaQuery).createCriteriaBuilder(getEntityManager()); if (entityViewClass == null) { return cb.getQuery(); } else { EntityViewSetting<?, ?> setting = EntityViewSetting.create(entityViewClass); setting = processSetting(setting, values); return evm.applySetting(setting, cb).getQuery(); } }
public <T> PagedList<T> getPaginatedCats(EntityViewSetting<T, PaginatedCriteriaBuilder<T>> setting) { CriteriaBuilder<Cat> cb = cbf.create(emHolder.getEntityManager(), Cat.class) .orderByAsc("name") .orderByAsc("id"); return evm.applySetting(setting, cb).withKeysetExtraction(true).getResultList(); } }