@Override @Transactional(value="defaultTransactionManager") public void clearDuplicateRefreshTokens() { Query query = manager.createQuery("select a.jwt, count(1) as c from OAuth2RefreshTokenEntity a GROUP BY a.jwt HAVING count(1) > 1"); @SuppressWarnings("unchecked") List<Object[]> resultList = query.getResultList(); List<JWT> values = new ArrayList<>(); for (Object[] r : resultList) { logger.warn("Found duplicate refresh tokens: {}, {}", ((JWT)r[0]).serialize(), r[1]); values.add((JWT) r[0]); } if (values.size() > 0) { CriteriaBuilder cb = manager.getCriteriaBuilder(); CriteriaDelete<OAuth2RefreshTokenEntity> criteriaDelete = cb.createCriteriaDelete(OAuth2RefreshTokenEntity.class); Root<OAuth2RefreshTokenEntity> root = criteriaDelete.from(OAuth2RefreshTokenEntity.class); criteriaDelete.where(root.get("jwt").in(values)); int result = manager.createQuery(criteriaDelete).executeUpdate(); logger.warn("Deleted {} duplicate refresh tokens", result); } }
@Override public int deleteAll() { return execute(session -> { CriteriaBuilder builder = session.getCriteriaBuilder(); CriteriaDelete<T> delete = builder.createCriteriaDelete(getEntityClass()); delete.from(getEntityClass()); return session.createQuery(delete).executeUpdate(); }); }
/** * Constructs the delete criteria query * * @param builder * @param query * @param root */ public <T extends Model> void constructQuery(CriteriaBuilder builder, CriteriaDelete<?> query, Root<T> root) { if (conditions != null || !conditions.isEmpty()) { List<Predicate> predicates = new ArrayList<Predicate>(); for (Condition condition : conditions) { predicates.add(condition.constructQuery(builder, root)); } query.where(predicates.toArray(new Predicate[0])); } }
@SuppressWarnings({"unchecked", "rawtypes"}) private void deleteAllEntities(Class<?>... entityTypes) { for (Class entityType : entityTypes) { CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaDelete query = builder.createCriteriaDelete(entityType); query.from(entityType); entityManager.createQuery(query).executeUpdate(); } }
/** * {@inheritDoc} */ @Override public Query createDeletionQuery(Class queryClazz, TranslationContext criteria) { CriteriaDelete jpaQuery = entityManager.getCriteriaBuilder().createCriteriaDelete(queryClazz); if (!criteria.predicates.isEmpty()) { jpaQuery = jpaQuery.where(criteria.getCriteriaPredicate()); } return entityManager.createQuery(jpaQuery); }
@Override @Transactional(value="defaultTransactionManager") public void clearDuplicateAccessTokens() { Query query = manager.createQuery("select a.jwt, count(1) as c from OAuth2AccessTokenEntity a GROUP BY a.jwt HAVING count(1) > 1"); @SuppressWarnings("unchecked") List<Object[]> resultList = query.getResultList(); List<JWT> values = new ArrayList<>(); for (Object[] r : resultList) { logger.warn("Found duplicate access tokens: {}, {}", ((JWT)r[0]).serialize(), r[1]); values.add((JWT) r[0]); } if (values.size() > 0) { CriteriaBuilder cb = manager.getCriteriaBuilder(); CriteriaDelete<OAuth2AccessTokenEntity> criteriaDelete = cb.createCriteriaDelete(OAuth2AccessTokenEntity.class); Root<OAuth2AccessTokenEntity> root = criteriaDelete.from(OAuth2AccessTokenEntity.class); criteriaDelete.where(root.get("jwt").in(values)); int result = manager.createQuery(criteriaDelete).executeUpdate(); logger.warn("Deleted {} duplicate access tokens", result); } }
@SuppressWarnings({"unchecked", "rawtypes"}) private void deleteAllEntities(Class<?>... entityTypes) { for (Class entityType : entityTypes) { CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaDelete query = builder.createCriteriaDelete(entityType); query.from(entityType); entityManager.createQuery(query).executeUpdate(); } }
protected <E extends Identifiable, T> void _deleteGlobalRecordsForType(E entity, EntityManager em, Class<T> clazz) { if(JPAEntity.class.isAssignableFrom(entity.getClass())) { JPAEntity jpaEntity = JPAEntity.class.cast(entity); CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaDelete<T> update = cb.createCriteriaDelete(clazz); Root<T> from = update.from(clazz); update.where(cb.equal(from.get("entity"), jpaEntity)); em.createQuery(update).executeUpdate(); }else { throw new IllegalArgumentException("Entity - " + entity.getClass() + " is not of type JPAEntity"); } }
@Override public int deleteAllDepartments() { CriteriaBuilder cb = this.em.getCriteriaBuilder(); CriteriaDelete<Department> cd = cb.createCriteriaDelete(Department.class); cd.from(Department.class); return this.em.createQuery(cd).executeUpdate(); } }
protected <E extends Identifiable, T> void _deleteGlobalRecordsForType(E entity, EntityManager em, Class<T> clazz) { if(JPAEntity.class.isAssignableFrom(entity.getClass())) { JPAEntity jpaEntity = JPAEntity.class.cast(entity); CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaDelete<T> update = cb.createCriteriaDelete(clazz); Root<T> from = update.from(clazz); update.where(cb.equal(from.get("entity"), jpaEntity)); em.createQuery(update).executeUpdate(); }else { throw new IllegalArgumentException("Entity - " + entity.getClass() + " is not of type JPAEntity"); } }
@Override public int deleteAllEmployees() { CriteriaBuilder cb = this.em.getCriteriaBuilder(); CriteriaDelete<Employee> cd = cb.createCriteriaDelete(Employee.class); cd.from(Employee.class); return this.em.createQuery(cd).executeUpdate(); }
@Override public void delete(Long primaryKey) { transactionControl.required(() -> { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaDelete<PersonEntity> query = builder.createCriteriaDelete(PersonEntity.class); Root<PersonEntity> from = query.from(PersonEntity.class); query.where(builder.equal(from.get("personId"), primaryKey)); em.createQuery(query).executeUpdate(); logger.info("Deleted Person with ID : {}", primaryKey); return null; }); }
protected static <T extends Model> void deleteAll(final Class<T> clazz, final Filter filter) { execute(manager -> { CriteriaBuilder builder = manager.getCriteriaBuilder(); CriteriaDelete<T> deleteQuery = builder.createCriteriaDelete(clazz); Root<T> root = deleteQuery.from(clazz); filter.constructQuery(builder, deleteQuery, root); Query query = createQuery(deleteQuery, filter); return query.executeUpdate(); }, false); }
@Override public void delete(Long primaryKey) { transactionControl.required(() -> { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaDelete<PersonEntity> query = builder.createCriteriaDelete(PersonEntity.class); Root<PersonEntity> from = query.from(PersonEntity.class); query.where(builder.equal(from.get("personId"), primaryKey)); em.createQuery(query).executeUpdate(); logger.info("Deleted Person with ID : {}", primaryKey); return null; }); }
@Transactional public void deleteAll() { CriteriaDelete<EntityWithCDIAwareBridges> delete = entityManager.getCriteriaBuilder() .createCriteriaDelete( EntityWithCDIAwareBridges.class ); delete.from( EntityWithCDIAwareBridges.class ); entityManager.createQuery( delete ).executeUpdate(); }
@Override public void delete(Long personId) { transactionControl.required(() -> { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaDelete<AddressEntity> query = builder.createCriteriaDelete(AddressEntity.class); Root<AddressEntity> from = query.from(AddressEntity.class); query.where(builder.equal(from.get("person").get("personId"), personId)); em.createQuery(query).executeUpdate(); return null; }); } }
/** * Removes all entities. Check on existence is made. * * @return the number of deleted entities. * @throws org.lorislab.jee.exception.ServiceException if the method fails. */ @TransactionAttribute(TransactionAttributeType.REQUIRED) public int deleteQueryAll() throws ServiceException { try { CriteriaBuilder cb = getEntityManager().getCriteriaBuilder(); CriteriaDelete<T> cq = cb.createCriteriaDelete(entityClass); cq.from(entityClass); return getEntityManager().createQuery(cq).executeUpdate(); } catch (Exception e) { throw new ServiceException(EntityServiceErrors.FAILED_TO_DELETE_ALL_QUERY, e, entityName); } }
@Override public void delete(Long personId) { transactionControl.required(() -> { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaDelete<AddressEntity> query = builder.createCriteriaDelete(AddressEntity.class); Root<AddressEntity> from = query.from(AddressEntity.class); query.where(builder.equal(from.get("person").get("personId"), personId)); em.createQuery(query).executeUpdate(); return null; }); } }
ftSession.getTransaction().begin(); CriteriaDelete<TShirt> delete = ftSession.getCriteriaBuilder().createCriteriaDelete( TShirt.class ); delete.from( TShirt.class ); ftSession.createQuery( delete ).executeUpdate(); ftSession.purgeAll( TShirt.class );
@Override public long remove(Specification<A> specification) { CriteriaBuilder cb = entityManager.getCriteriaBuilder(); Class<A> entityClass = getAggregateRootClass(); CriteriaDelete<A> cd = cb.createCriteriaDelete(entityClass); cd.where(specificationTranslator .translate(specification, new JpaTranslationContext<>(cb, cd.from(entityClass)))); return entityManager.createQuery(cd).executeUpdate(); }