Spring Data: "Elimina entro" è supportato?

Sto usando Spring JPA per l'accesso al database. Sono in grado di trovare esempi come findByName e countByName, per i quali non devo scrivere alcuna implementazione del metodo. Spero di trovare esempi per eliminare un gruppo di record in base a qualche condizione.

Spring JPA supporta l'eliminazione di tipo deleteByName? Qualsiasi suggerimento è apprezzato.

Saluti e grazie.

Risposta obsoleta (Spring Data JPA <= 1.6.x) :

@Modifyingannotazione in soccorso. Tuttavia, dovrai fornire il tuo comportamento SQL personalizzato.

public interface UserRepository extends JpaRepository<User, Long> {
    @Modifying
    @Query("delete from User u where u.firstName = ?1")
    void deleteUsersByFirstName(String firstName);
}

Aggiornare:

Nelle versioni moderne di primavera dati JPA (> = 1.7.x) di query di derivazione per delete, removee countle operazioni è accessibile.

public interface UserRepository extends CrudRepository<User, Long> {

    Long countByFirstName(String firstName);

    Long deleteByFirstName(String firstName);

    List<User> removeByFirstName(String firstName);

}

La derivazione delle query di eliminazione utilizzando il nome del metodo specificato è supportata a partire dalla versione 1.6.0.RC1 di Spring Data JPA. Le parole chiave removee deletesono supportate. Come valore di ritorno si può scegliere tra il numero o un elenco di entità rimosse.

Long removeByLastname(String lastname);

List<User> deleteByLastname(String lastname);

Se dai un'occhiata al codice sorgente di Spring Data JPA, e in particolare alla PartTreeJpaQueryclasse, vedrai che sta cercando di istanziare PartTree. All'interno di quella classe la seguente espressione regolare

private static final Pattern PREFIX_TEMPLATE = Pattern.compile("^(find|read|get|count|query)(\\p{Lu}.*?)??By")

dovrebbe indicare cosa è consentito e cosa no.

Ovviamente se provi ad aggiungere un tale metodo vedrai effettivamente che non funziona e ottieni lo stacktrace completo.

Dovrei notare che stavo usando guardando la versione 1.5.0.RELEASEdi Spring Data JPA

2 modi: -

La prima query personalizzata

@Modifying
@Query("delete from User where firstName = :firstName")
void deleteUsersByFirstName(@Param("firstName") String firstName);

Secondo JPA Query per metodo

List<User> deleteByLastname(String lastname);

Quando vai con la query per metodo (secondo metodo), prima eseguirà una chiamata get

select * from user where last_name = :firstName

Quindi lo caricherà in una lista Quindi chiamerà delete id uno per uno

delete from user where id = 18
delete from user where id = 19

Prima recupera l'elenco di oggetti, quindi for loop per eliminare gli id ​​uno per uno

Ma la prima opzione (query personalizzata),

È solo una singola query Eliminerà ovunque il valore esista.

Vai anche attraverso questo link https://www.baeldung.com/spring-data-jpa-deleteby

Se si utilizzano metodi di eliminazione predefiniti forniti direttamente da Spring JPA, il framework eseguirà le due query di seguito.

• Per prima cosa raccogli i dati (come id e altre colonne) usando eseguendo la query di selezione con la clausola di cancellazione della query.

• quindi dopo aver ottenuto il set di risultati della prima query, verranno eseguite le seconde query di eliminazione per tutti gli ID (una per una)

  Nota: questo non è un modo ottimizzato per la tua applicazione perché molte query verranno eseguite per una singola query di eliminazione MYSQL.

Questo è un altro modo ottimizzato per eliminare il codice della query perché verrà eseguita solo una query di eliminazione utilizzando i metodi personalizzati di seguito.

@NamedNativeQueries({

@NamedNativeQuery(name = "Abc.deleteByCreatedTimeBetween",
            query = "DELETE FROM abc WHERE create_time BETWEEN ?1 AND ?2")
    ,

    @NamedNativeQuery(name = "Abc.getByMaxId",
            query = "SELECT max(id) from abc")
})

@Entity
public class Abc implements Serializable {

}

@Repository
public interface AbcRepository extends CrudRepository {

    int getByMaxId();

    @Transactional
    @Modifying
    void deleteByCreatedTimeBetween(String startDate, String endDate);
}

Prestare attenzione quando si utilizza la query derivata per l'eliminazione in batch. Non è quello che ti aspetti: DeleteExecution

Sì, il metodo deleteBy è supportato Per usarlo è necessario annotare il metodo con @Transactional