@Test public void shouldDeleteDocumentBySpecifiedTypeUsingDeleteQuery() { // given String documentId = randomNumeric(5); SampleEntity sampleEntity = new SampleEntity(); sampleEntity.setId(documentId); sampleEntity.setMessage("some message"); sampleEntity.setVersion(System.currentTimeMillis()); IndexQuery indexQuery = new IndexQuery(); indexQuery.setId(documentId); indexQuery.setObject(sampleEntity); elasticsearchTemplate.index(indexQuery); // when DeleteQuery deleteQuery = new DeleteQuery(); deleteQuery.setQuery(fieldQuery("id", documentId)); deleteQuery.setIndex("test-index"); deleteQuery.setType("test-type"); elasticsearchTemplate.delete(deleteQuery); // then SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(fieldQuery("id", documentId)).build(); Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery, SampleEntity.class); assertThat(sampleEntities.getTotalElements(), equalTo(0L)); }
@Override public void delete(DeleteQuery deleteQuery) { Assert.notNull(deleteQuery.getIndex(), "No index defined for Query"); Assert.notNull(deleteQuery.getType(), "No type define for Query"); client .prepareDeleteByQuery(deleteQuery.getIndex()) .setTypes(deleteQuery.getType()) .setQuery(deleteQuery.getQuery()) .execute() .actionGet(); }
public void delete(DeleteQuery query) throws DBException { try { query.setDb(this); Session session = this.beginTransaction(); query.query(session); this.commit(); } catch (DBException e) { this.rollback(); throw e; } catch (Exception e) { this.rollback(); throw new DBException("Delete Error: ", e); } finally { this.endTransaction(); } }
@Override public <T> void delete(DeleteQuery deleteQuery, Class<T> clazz) { ElasticsearchPersistentEntity persistentEntity = getPersistentEntityFor(clazz); client .prepareDeleteByQuery(persistentEntity.getIndexName()) .setTypes(persistentEntity.getIndexType()) .setQuery(deleteQuery.getQuery()) .execute() .actionGet(); }
/** * Builds a reusable query object for deletion (Query objects can be executed more efficiently * than creating a QueryBuilder for each execution. */ public DeleteQuery<T> buildDelete() { if (!joins.isEmpty()) { throw new DaoException("JOINs are not supported for DELETE queries"); } String tablename = dao.getTablename(); String baseSql = SqlUtils.createSqlDelete(tablename, null); StringBuilder builder = new StringBuilder(baseSql); // tablePrefix gets replaced by table name below. Don't use tableName here because it causes // trouble when // table name ends with tablePrefix. appendJoinsAndWheres(builder, tablePrefix); String sql = builder.toString(); // Remove table aliases, not supported for DELETE queries. // TODO(?): don't create table aliases in the first place. sql = sql.replace(tablePrefix + ".\"", '"' + tablename + "\".\""); checkLog(sql); return DeleteQuery.create(dao, sql, values.toArray()); }
/** * delete a list of beans. * * @param beans the beans * @param session the Session * @param consistency the consistency Level on Cassandra * @param <T> th kind of object * @return if execute with Sucess */ public <T> boolean delete(Iterable<T> beans, Session session, ConsistencyLevel consistency) { return deleteQuery.deleteByKey(beans, session, consistency); }
/** * delete on object from cassandra by Key. * * @param bean the kind of object * @param session the Session * @param <T> kind of object * @param consistency the consistency level * @return if execute the command */ public <T> boolean delete(T bean, Session session, ConsistencyLevel consistency) { return deleteQuery.deleteByKey(bean, session, consistency); }
/** * delete on object from cassandra by Key. * * @param session the Session * @param consistency the consistency Level * @param entity the entity * @param <K> the keys * @param keys the keys values * @param <T> the kind of object * @return if execute the command */ public <K, T> boolean deleteByKey( Iterable<K> keys, Class<T> entity, Session session, ConsistencyLevel consistency) { deleteQuery.deleteByKey(keys, entity, session, consistency); return true; }
/** * delete on object from cassandra by Key. * * @param key the key * @param bean the bean * @return the delete */ public Delete runDelete(Object key, Class<?> bean) { return deleteQuery.runDelete(key, bean, ConsistencyLevel.ONE); }
/** * delete on object from cassandra by Key. * * @param key the key * @param bean the kind of object * @param session the Session * @param consistency the consistency Level * @return if execute the command */ public boolean deleteByKey( Object key, Class<?> bean, Session session, ConsistencyLevel consistency) { return deleteQuery.deleteByKey(key, bean, session, consistency); }