Query at JPA repo from list object - list

Question

Need to ask query in JPA repository.
I have entity mapped like this
private String name;
private Set<String> roles;
There are two different string roles "users" and "managers"
Need to list all users and all managers respectively
tried
findAllByRolesContains(String role);
Than tried:
return userRepository.findAllByRolesContains("users");
Received response
Parameter value [%users%] did not match expected type
How should I ask it right?
tried
findAllByInRolesContains(String role);
it did not work at all

Answer 1

So first off, I see you didn't add the tags for "spring" and "spring data jpa" to your question. I want to remind you, that you are showing code snippets for Spring Data JPA - so a part of the Spring framework that builds upon the Java Persistence API (JPA). Make sure you understand the basics (JPA) first! Spring Data builds JPA queries under the hood and automates a lot of stuff, but it won't save you from knowing how to use JPA!
Next, if you have specific roles, i.e., not arbitrary strings ("role1324"), you might want to map an Enum instead.
But let's look at your case:
#Entity
public class User {
#Id
private String name;
#ElementCollection
private Set<String> roles;
}
So you are trying to create a query method for your repository - Spring Data generates queries based on the name of the method. The rules can be found in the reference documentation.
So what does findAllByRolesContains generate? Anything between 'find' and 'By' is just descriptive, i.e., ignored. 'Roles' is the property and 'Contains' may mean "contained in a collection" or "contained in a string".
But we are missing a level here - you want to check if a string in a collection contains something. And I have not found a way to tell Spring Data to create the correct query.
findAllByRolesLike is the closest one, but then you have to manually wrap the search string with '%'s.
Getting Spring Data to create the correct query can be fickle and if it's not straight forward, a waste of time IMHO. You can always write the query yourself:
#Query("select user from User user join user.roles role where role like %:role%")
List<User> findAllByRolesContaining(#Param("role") String role);
But if you test this with a User with roles ["admin", "administrator"], you get the same user twice?! What gives?! Well, that's just how the underlying SQL works - it filters rows and there are two rows with "username - admin" and "username - administrator".
You want the distrinct keyword to filter them out:
#Query("select distinct user from User user join user.roles role where role like %:role%")
List<User> findAllByRolesContaining(#Param("role") String role);
One more optimization: If roles is an #ElementCollection, they are fetched lazily by default. If you know that you will need to access it, you can add a join fetch user.roles before the join. This will load it eagerly. You can create 2 different methods if you like. You want to avoid fetching them if you don't need them, but if you know you'll need them, lazy loading may issue multiple queries.
The wikibook on JPA is a great resource and the book and blog of Vlad Mihalcea are the best resources on high performance JPA you can find.
Also - don't rely too much on the auto-magic of Spring Data JPA, IMHO it does more harm than good for anything but the most trivial of queries...