Interface PersonRepository

All Superinterfaces:

CrudRepository<Person,Long>, GenericRepository<Person,Long>, JpaSpecificationExecutor<Person>, PageableRepository<Person,Long>

public interface PersonRepository
extends CrudRepository<Person,Long>, PageableRepository<Person,Long>, JpaSpecificationExecutor<Person>

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static final class	PersonRepository.Specifications

Method Summary

Modifier and Type	Method	Description
int	count(String name)
int	countByAgeGreaterThan(Integer wrapper)
int	countByAgeLessThan(int wrapper)
Long	deleteByNameLike(String name)
int	deleteCustom(List<Person> people)
int	deleteCustomSingle(Person person)
int	deleteCustomSingleExpression(Person person)
int	deleteCustomSingleNoEntity(String xyz)
Slice<Person>	find(Pageable pageable)
int	findAgeByName(String name)
@NonNull CursoredPage<Person>	findAll(@Nullable @Nullable PredicateSpecification<Person> spec, CursoredPageable pageable)
List<Person>	findAllByAgeInRange(int from, int to)
List<Person>	findAllByName(String name)
List<Person>	findAllByNameLike(String name, Pageable pageable)
@Nullable @Nullable Person	findByName(String name)
List<Person>	findByNameLike(String name)
Page<Person>	findByNameLike(String name, Pageable pageable)
List<Person>	findByNameLikeOrderByAge(String name)
List<Person>	findByNameLikeOrderByAgeDesc(String name)
List<Person>	findDistinct()
List<String>	findDistinctName()
int	findMaxAgeByNameLike(String name)
int	findMinAgeByNameLike(String name)
Optional<Person>	findOptionalByName(String name)
Page<Person>	findPeople(String n, Pageable pageable)
Person	get(Long id)
long	getAvgAgeByNameLike(String name)
Person	getByName(String name)
int	getSumAgeByNameLike(String name)
TotalDto	getTotal()
List<Person>	list(Pageable pageable)
List<Person>	listTop10(Sort sort)
Slice<Person>	queryByNameLike(String name, Pageable pageable)
List<Person>	queryNames(List<String> names0, String names1, List<String> names2, List<String> names3, String name4)
List<Integer>	readAgeByNameLike(String name)
CursoredPage<Person>	retrieve(@NonNull Pageable pageable)
Person	save(String name, int age)
int	saveCustom(String xyz, int age)
int	saveCustom(List<Person> people)
int	saveCustomSingle(Person people)
int	saveCustomSingleExpression(Person person)
int	saveCustomSingleExpression2(String name, String age)
long	updateAll(List<Person> people)
long	updateByName(String name, int age)
void	updateByName(String name, Person person)
Person	updateByNameAndAge(String name, int age, Person person)
long	updateCustomOnlyNames(List<Person> people)
long	updateNamesCustom(String newName, String oldName)
List<Person>	updatePeople(List<Person> people)
Long	updatePerson(Long id, int age)
void	updatePerson(Long id, String name)
long	updatePersonCount(Long id, String name)
long	updatePersonCustom(Long xyz)
Future<Long>	updatePersonCustomFuture(Long xyz)
io.reactivex.Single<Long>	updatePersonCustomRx(Long id)
CompletableFuture<Long>	updatePersonFuture(Long id, String name)
io.reactivex.Single<Long>	updatePersonRx(Long id, String name)

Methods inherited from interface CrudRepository

count, delete, deleteAll, deleteAll, deleteById, existsById, findAll, findById, save, saveAll, update, updateAll

Methods inherited from interface JpaSpecificationExecutor

count, count, deleteAll, deleteAll, deleteAll, exists, exists, findAll, findAll, findAll, findAll, findAll, findAll, findAll, findOne, findOne, findOne, updateAll, updateAll

Methods inherited from interface PageableRepository

findAll, findAll

Method Details

getTotal

@Query("select count(*) as total from person")
TotalDto getTotal()

countByAgeGreaterThan

int countByAgeGreaterThan(Integer wrapper)

countByAgeLessThan

int countByAgeLessThan(int wrapper)

save

Person save(@Parameter("name")
 String name,
 @Parameter("age")
 int age)

saveCustom

@Query("INSERT INTO person(name, age, enabled) VALUES (:xyz, :age, TRUE)")
int saveCustom(@Parameter("xyz")
 String xyz,
 @Parameter("age")
 int age)

get

Person get(Long id)

updatePerson

void updatePerson(@Id
 Long id,
 @Parameter("name")
 String name)

updatePersonCount

long updatePersonCount(@Id
 Long id,
 @Parameter("name")
 String name)

updatePersonRx

io.reactivex.Single<Long> updatePersonRx(@Id
 Long id,
 @Parameter("name")
 String name)

updatePersonCustomRx

@Query("UPDATE person SET name = 'test' WHERE id = :id")
io.reactivex.Single<Long> updatePersonCustomRx(Long id)

updatePersonCustomFuture

@Query("UPDATE person SET name = 'test' WHERE id = :xyz")
Future<Long> updatePersonCustomFuture(Long xyz)

updatePersonCustom

@Query("UPDATE person SET name = 'test' WHERE id = :xyz")
long updatePersonCustom(Long xyz)

queryNames

@Query("SELECT * FROM person WHERE name = :names1 or name IN(:names3) or name IN(:names0) or (:name4 = name)")
List<Person> queryNames(List<String> names0,
 String names1,
 List<String> names2,
 List<String> names3,
 String name4)

updatePersonFuture

CompletableFuture<Long> updatePersonFuture(@Id
 Long id,
 @Parameter("name")
 String name)

updateByName

long updateByName(String name,
 int age)

updateByName

void updateByName(String name,
 Person person)

list

List<Person> list(Pageable pageable)

count

int count(String name)

findByName

@Nullable
@Nullable @Nullable Person findByName(String name)

deleteByNameLike

Long deleteByNameLike(String name)

getByName

Person getByName(String name)

findByNameLike

List<Person> findByNameLike(String name)

findAgeByName

int findAgeByName(String name)

findMaxAgeByNameLike

int findMaxAgeByNameLike(String name)

findMinAgeByNameLike

int findMinAgeByNameLike(String name)

getSumAgeByNameLike

int getSumAgeByNameLike(String name)

getAvgAgeByNameLike

long getAvgAgeByNameLike(String name)

readAgeByNameLike

List<Integer> readAgeByNameLike(String name)

findByNameLikeOrderByAge

List<Person> findByNameLikeOrderByAge(String name)

findByNameLikeOrderByAgeDesc

List<Person> findByNameLikeOrderByAgeDesc(String name)

findByNameLike

Page<Person> findByNameLike(String name,
 Pageable pageable)

listTop10

List<Person> listTop10(Sort sort)

find

Slice<Person> find(Pageable pageable)

queryByNameLike

Slice<Person> queryByNameLike(String name,
 Pageable pageable)

findOptionalByName

Optional<Person> findOptionalByName(String name)

findAllByName

List<Person> findAllByName(String name)

findAllByNameLike

List<Person> findAllByNameLike(String name,
 Pageable pageable)

findPeople

@Query(value="select * from person person_ where person_.name like :n",
       countQuery="select count(*) from person person_ where person_.name like :n")
Page<Person> findPeople(String n,
 Pageable pageable)

updateAll

long updateAll(List<Person> people)

updatePeople

List<Person> updatePeople(List<Person> people)

updateNamesCustom

@Query("UPDATE person SET name = :newName WHERE (name = :oldName)")
long updateNamesCustom(String newName,
 String oldName)

updateCustomOnlyNames

@Query("UPDATE person SET name = :name WHERE id = :id")
long updateCustomOnlyNames(List<Person> people)

saveCustom

@Query("INSERT INTO person(name, age, enabled) VALUES (:name, :age, TRUE)")
int saveCustom(List<Person> people)

saveCustomSingle

@Query("INSERT INTO person(name, age, enabled) VALUES (:name, :age, TRUE)")
int saveCustomSingle(Person people)

saveCustomSingleExpression

@Query("INSERT INTO person(name, age, enabled) VALUES (:name, :age, TRUE)")
@ParameterExpression(name="name",expression="#{person.name + 'XYZ'}") @ParameterExpression(name="age",expression="#{person.age}")
int saveCustomSingleExpression(Person person)

saveCustomSingleExpression2

@Query("INSERT INTO person(name, age, enabled) VALUES (:name, :age, TRUE)")
@ParameterExpression(name="name",
                     expression="#{name + 'XYZ'}")
int saveCustomSingleExpression2(String name,
 String age)

deleteCustom

@Query("DELETE FROM person WHERE name = :name")
int deleteCustom(List<Person> people)

deleteCustomSingle

@Query("DELETE FROM person WHERE name = :name")
int deleteCustomSingle(Person person)

deleteCustomSingleExpression

@Query("DELETE FROM person WHERE name = :name")
@ParameterExpression(name="name",
                     expression="#{person.name}")
int deleteCustomSingleExpression(Person person)

deleteCustomSingleNoEntity

@Query("DELETE FROM person WHERE name = :xyz")
int deleteCustomSingleNoEntity(String xyz)

findAllByAgeInRange

List<Person> findAllByAgeInRange(int from,
 int to)

updateByNameAndAge

Person updateByNameAndAge(String name,
 int age,
 Person person)

updatePerson

Long updatePerson(@Id
 Long id,
 @Parameter("age")
 int age)

findDistinct

List<Person> findDistinct()

findDistinctName

List<String> findDistinctName()

retrieve

CursoredPage<Person> retrieve(@NonNull Pageable pageable)

findAll

@NonNull CursoredPage<Person> findAll(@Nullable
 @Nullable @Nullable PredicateSpecification<Person> spec,
 CursoredPageable pageable)