@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);
}
