Spring/spring-data-neo4j
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

DATAGRAPH-1300 - Change query paramater style.

Browse Source 
Use the $-style instead of the deprecated {}.
This commit is contained in:
Gerrit Meier
2020-03-03 16:51:47 +01:00
parent 357e6fb5e5
commit d19edc2815
10 changed files with 50 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
spring-data-neo4j/src/main/java/org/springframework/data/neo4j/repository/query/Query.java
View File

@@ -39,7 +39,7 @@ public class Query {
private static final String SKIP = "sdnSkip";
private static final String LIMIT = "sdnLimit";
private static final String SKIP_LIMIT = " SKIP {" + SKIP + "} LIMIT {" + LIMIT + "}";
private static final String SKIP_LIMIT = " SKIP $" + SKIP + " LIMIT $" + LIMIT;
private static final String ORDER_BY_CLAUSE = " ORDER BY %s";
private Filters filters;

4
spring-data-neo4j/src/main/java/org/springframework/data/neo4j/repository/query/filter/DistanceComparisonBuilder.java
View File

@@ -153,8 +153,8 @@ class DistanceComparisonBuilder extends FilterBuilder {
String longitudeProperty = nodeIdentifier + ".longitude";
return String.format(
"distance(coalesce(point({latitude: %s, longitude: %s}), %s), point({latitude:{lat}, longitude:{lon}})) "
+ "%s {distance} ",
"distance(coalesce(point({latitude: %s, longitude: %s}), %s), point({latitude:$lat, longitude:$lon})) "
+ "%s $distance ",
latitudeProperty, longitudeProperty, nodeIdentifier + "." + propertyName(),
ComparisonOperator.LESS_THAN.getValue());
}

2
spring-data-neo4j/src/main/java/org/springframework/data/neo4j/repository/query/spel/Neo4jQueryPlaceholderSupplier.java
View File

@@ -31,6 +31,6 @@ public class Neo4jQueryPlaceholderSupplier implements PlaceholderSupplier {
@Override
public String decoratePlaceholder(String placeholder) {
return "{" + placeholder + "}";
return "$" + placeholder;
}
}

2
spring-data-neo4j/src/test/java/org/springframework/data/neo4j/examples/friends/repo/FriendshipRepository.java
View File

@@ -25,7 +25,7 @@ import org.springframework.data.neo4j.repository.Neo4jRepository;
*/
public interface FriendshipRepository extends Neo4jRepository<Friendship, Long> {
@Query("MATCH (person1)-[rel:IS_FRIEND]->(person2) WHERE ID(person1)={0} AND ID(person2)={1} return rel")
@Query("MATCH (person1)-[rel:IS_FRIEND]->(person2) WHERE ID(person1)=$0 AND ID(person2)=$1 return rel")
Friendship getFriendship(Person person1, Person person2);
}

4
spring-data-neo4j/src/test/java/org/springframework/data/neo4j/examples/movies/repo/CinemaRepository.java
View File

@@ -101,8 +101,8 @@ public interface CinemaRepository extends Neo4jRepository<Cinema, Long> {
@Query(value = "MATCH (n:Theatre) RETURN n", countQuery = "MATCH (n:Theatre) return count(*)")
Page<CinemaQueryResultInterface> getPagedCinemaQueryResultInterfaces(Pageable pageable);
@Query(value = "MATCH (n:Theatre {city:{city}}) RETURN n ORDER BY n.name",
countQuery = "MATCH (n:Theatre {city:{city}}) return count(*)")
@Query(value = "MATCH (n:Theatre {city:$city}) RETURN n ORDER BY n.name",
countQuery = "MATCH (n:Theatre {city:$city}) return count(*)")
Page<Cinema> getPagedCinemasByCityWithPageCount(@Param("city") String city, Pageable pageable);
@Query("MATCH (n:Theatre) RETURN n")

2
spring-data-neo4j/src/test/java/org/springframework/data/neo4j/examples/movies/repo/RatingRepository.java
View File

@@ -59,6 +59,6 @@ public interface RatingRepository extends Neo4jRepository<Rating, Long> {
List<Long> deleteByStarsOrRatingTimestampGreaterThan(int stars, long ratingTimestamp);
@Query("MATCH (a)-[r:RATED]-(b) WHERE ID(a)={0} and ID(b)={1} RETURN a,r,b")
@Query("MATCH (a)-[r:RATED]-(b) WHERE ID(a)=$0 and ID(b)=$1 RETURN a,r,b")
Rating findRatingByUserAndTempMovie(long userId, long tempMovieId);
}

38
spring-data-neo4j/src/test/java/org/springframework/data/neo4j/examples/movies/repo/UserRepository.java
View File

@@ -69,40 +69,40 @@ public interface UserRepository extends PersonRepository<User, Long> {
@Query("MATCH (m:Movie)<-[:ACTED_IN]-(a:User) RETURN m.name as movie, collect(a.name) as cast")
List<Map<String, Object>> getGraph();
@Query("MATCH (user:User{name:{name}}) RETURN user")
@Query("MATCH (user:User{name:$name}) RETURN user")
User findUserByNameWithNamedParam(@Param("name") String name);
@Query("MATCH (user:User{name:{name}}) RETURN user")
@Query("MATCH (user:User{name:$name}) RETURN user")
User findUserByNameWithNamedParamWithoutParamAnnotation(String name);
@Query("MATCH (user:User{name:{0}}) RETURN user")
@Query("MATCH (user:User{name:$0}) RETURN user")
User findUserByName(String name);
@Query("MATCH (user:User) RETURN id(user) AS userId, id(user) as id, user.name AS userName, user.age ORDER BY user.age")
Iterable<UserQueryResult> retrieveAllUsersAndTheirAges();
@Query("MATCH (user:User{name:{0}}) RETURN user.name AS name")
@Query("MATCH (user:User{name:$0}) RETURN user.name AS name")
UnmanagedUserPojo findIndividualUserAsDifferentObject(String name);
@Query("MATCH (user:User) WHERE user.name={0} RETURN user.name AS name, user.age AS ageOfUser")
@Query("MATCH (user:User) WHERE user.name=$0 RETURN user.name AS name, user.age AS ageOfUser")
UserQueryResultObject findIndividualUserAsProxiedObject(String name);
@Query("MATCH (user:User) WHERE user.name={0} RETURN user as user, user.age AS ageOfUser")
@Query("MATCH (user:User) WHERE user.name=$0 RETURN user as user, user.age AS ageOfUser")
UserQueryResultObject findWrappedUserAsProxiedObject(String name);
@Query("MATCH (user:User) WHERE user.gender={0} RETURN user.name AS userName, user.gender AS userGender, user.account as userAccount, user.yearOfBirth as yearOfBirth, user.yearOfBirth as plainYearValue, user.deposits as userDeposits")
@Query("MATCH (user:User) WHERE user.gender=$0 RETURN user.name AS userName, user.gender AS userGender, user.account as userAccount, user.yearOfBirth as yearOfBirth, user.yearOfBirth as plainYearValue, user.deposits as userDeposits")
Iterable<RichUserQueryResult> findUsersByGender(Gender gender);
@Query("MATCH (user:User) WHERE user.name={0} RETURN user")
@Query("MATCH (user:User) WHERE user.name=$0 RETURN user")
EntityWrappingQueryResult findWrappedUserByName(String userName);
@Query("MATCH (user:User)-[:FRIEND_OF]->(f) WHERE user.name={0} RETURN user, collect(f) as friends")
@Query("MATCH (user:User)-[:FRIEND_OF]->(f) WHERE user.name=$0 RETURN user, collect(f) as friends")
EntityWrappingQueryResult findWrappedUserAndFriendsDepth0(String userName);
@Query("MATCH (user:User)-[r:FRIEND_OF]->(f) WHERE user.name={0} RETURN user, collect(r) as rels, collect(f) as friends")
@Query("MATCH (user:User)-[r:FRIEND_OF]->(f) WHERE user.name=$0 RETURN user, collect(r) as rels, collect(f) as friends")
EntityWrappingQueryResult findWrappedUserAndFriendsDepth1(String userName);
@Query("MATCH (user:User)-[r:RATED]->(m) WHERE user.name={0} RETURN user, collect(r) as ratings, collect(m) as movies, avg(r.stars) as avgRating")
@Query("MATCH (user:User)-[r:RATED]->(m) WHERE user.name=$0 RETURN user, collect(r) as ratings, collect(m) as movies, avg(r.stars) as avgRating")
EntityWrappingQueryResult findWrappedUserAndRatingsByName(String userName);
@Query("MATCH (user:User)-[r:RATED]->(m) RETURN user, collect(r) as ratings, collect(m) as movies, avg(r.stars) as avgRating order by user.name desc")
@@ -111,16 +111,16 @@ public interface UserRepository extends PersonRepository<User, Long> {
@Query("MATCH (user:User) RETURN ID(user)")
List<Long> getUserNodeIds();
@Query("MATCH (user:User) WHERE ID(user)={0} return user")
@Query("MATCH (user:User) WHERE ID(user)=$0 return user")
User loadUserById(User user);
@Query("MATCH (user:User) WHERE ID(user)={userId} RETURN user")
@Query("MATCH (user:User) WHERE ID(user)=$userId RETURN user")
User loadUserByNamedId(@Param("userId") User user);
@Query("MATCH (user:User) RETURN user")
Iterable<User> getAllUsersIterable();
@Query("MATCH (user:User) set user.name={0}")
@Query("MATCH (user:User) set user.name=$0")
void setNamesNull(String name);
List<User> findByNameIsNotLike(String name);
@@ -157,7 +157,7 @@ public interface UserRepository extends PersonRepository<User, Long> {
@Query("MATCH (user:User) WHERE user.name=?#{[0]} RETURN user")
User findUserByNameUsingSpElWithIndex(String name);
@Query("MATCH (user:User) WHERE user.name=:#{[0]} and user.name=:#{[0]}RETURN user")
@Query("MATCH (user:User) WHERE user.name=:#{[0]} and user.name=:#{[0]} RETURN user")
User findUserByNameUsingSpElWithIndexColon(String name);
@Query("MATCH (user:User) WHERE user.age=?#{5 + 5} RETURN user")
@@ -169,13 +169,13 @@ public interface UserRepository extends PersonRepository<User, Long> {
@Query("MATCH (user:User) WHERE user.name=:#{'Michal'} RETURN user")
User findUserByNameAndMiddleNameUsingSpElWithValue();
@Query("MATCH (user:User) WHERE user.name=?#{[0]} and user.surname={name} RETURN user")
@Query("MATCH (user:User) WHERE user.name=?#{[0]} and user.surname=$name RETURN user")
User findUserByNameAndSurnameUsingSpElIndexAndPlaceholderWithOneParameter(@Param("name") String queryName);
@Query("MATCH (user:User) WHERE user.name=:#{#name} and user.surname={name} RETURN user")
@Query("MATCH (user:User) WHERE user.name=:#{#name} and user.surname=$name RETURN user")
User findUserByNameAndSurnameUsingSpElPropertyAndPlaceholderWithOneParameter(@Param("name") String queryName);
@Query("MATCH (user:User) WHERE user.name=:#{#name} and user.surname={name} RETURN user")
@Query("MATCH (user:User) WHERE user.name=:#{#name} and user.surname=$name RETURN user")
User findUserByNameAndSurnameUsingSpElPropertyAndIndexWithOneParameter(@Param("name") String queryName);
@Query("MATCH (user:User) WHERE user.name=:#{#name} and user.surname=:#{#name} RETURN user")
@@ -184,6 +184,6 @@ public interface UserRepository extends PersonRepository<User, Long> {
@Query("MATCH (user:User) WHERE user.name=:#{#name} and user.surname=:#{[0]} RETURN user")
User findUserByNameAndSurnameUsingSpElPropertyAndSpElIndex(@Param("name") String queryName);
@Query("MATCH (user:User) WHERE user.name={name} and user.name={0} and user.name=:#{#name} and user.name=:#{[0]} RETURN user")
@Query("MATCH (user:User) WHERE user.name=$name and user.name=$0 and user.name=:#{#name} and user.name=:#{[0]} RETURN user")
User findUserByNameUsingNativeIndexAndNameAndSpElNameAndSpElIndex(@Param("name") String queryName);
}

2
spring-data-neo4j/src/test/java/org/springframework/data/neo4j/repository/sample/UserRepository.java
View File

@@ -72,7 +72,7 @@ public interface UserRepository extends Neo4jRepository<User, Long> {
* @param emailAddress
* @return
*/
@Query("MATCH (n:User{emailAddress:{emailAddress}}) return n")
@Query("MATCH (n:User{emailAddress:$emailAddress}) return n")
@Transactional(readOnly = true)
User findByAnnotatedQuery(@Param("emailAddress") String emailAddress);
}

8
spring-data-neo4j/src/test/resources/META-INF/neo4j-named-queries.properties
View File

@@ -1,5 +1,5 @@
SampleEntityForNamedQuery.findByQueryWithoutParameter=MATCH (e) WHERE e.name='test' RETURN e
SampleEntityForNamedQuery.findByQueryWithParameter=MATCH (e) WHERE e.name={name} RETURN e
SampleEntityForNamedQuery.findByPagedQueryWithParameter=MATCH (e) WHERE e.name={name} RETURN e
SampleEntityForNamedQuery.findByPagedQueryWithParameter.countQuery=MATCH (e) WHERE e.name={name} RETURN count(e)
SampleEntityForNamedQuery.findByPagedQueryWithoutCountQuery=MATCH (e) WHERE e.name={name} RETURN e
SampleEntityForNamedQuery.findByQueryWithParameter=MATCH (e) WHERE e.name=$name RETURN e
SampleEntityForNamedQuery.findByPagedQueryWithParameter=MATCH (e) WHERE e.name=$name RETURN e
SampleEntityForNamedQuery.findByPagedQueryWithParameter.countQuery=MATCH (e) WHERE e.name=$name RETURN count(e)
SampleEntityForNamedQuery.findByPagedQueryWithoutCountQuery=MATCH (e) WHERE e.name=$name RETURN e

36
src/main/asciidoc/reference/neo4j-repositories.adoc
View File

@@ -230,10 +230,10 @@ Depending on the `Range` definition `n.score >= min AND n.score \<= max` or
Queries using the Cypher graph query language can be supplied with the `@Query` annotation.
That means a repository method annotated with +
`@Query("MATCH (:Actor {name:{name}})-[:ACTED_IN]\->(m:Movie) return m")` +
`@Query("MATCH (:Actor {name:$name})-[:ACTED_IN]\->(m:Movie) return m")` +
will use the supplied query to retrieve data from Neo4j.
The named or indexed parameter `{param}` will be substituted by the actual method parameter.
The named or indexed parameter `$param` will be substituted by the actual method parameter.
Node and relationship entities are handled directly and converted into their respective ids.
All other parameters types are provided directly (i.e. `String`, `Long`, etc.).
@@ -254,7 +254,7 @@ Instead, return nodes and relationships to have them mapped to domain entities.
Sometimes it makes sense to extract e.g. a long query.
Spring Data Neo4j will look in the `META-INF/neo4j-named-queries.properties` file to find named queries.
If you provide a query property like `User.findByQuery=MATCH (e) WHERE e.name={name} RETURN e` you can refer to this method by providing a finder method in your repository.
If you provide a query property like `User.findByQuery=MATCH (e) WHERE e.name=$name RETURN e` you can refer to this method by providing a finder method in your repository.
The repository has to support the given entity type (in this example `User`) and the method has to be named as the defined one (`findByQuery`).
As you can see in the example it is possible to parameterize the query.
Named count query can be specified by adding `.countQuery` suffix to the related query property key. For example, if the next query should return paged result `User.findAllByQuery=MATCH (e) RETURN e`, the count query can be specified by the following way: `User.findAllByQuery.countQuery=MATCH (e) RETURN count(e)`.
@@ -290,38 +290,38 @@ as described in the <<reference_programming_model_annotatedQueries>>) section.
public interface MovieRepository extends Neo4jRepository<Movie, Long> {
// returns the node with id equal to idOfMovie parameter
@Query("MATCH (n) WHERE id(n)={0} RETURN n")
@Query("MATCH (n) WHERE id(n)=$0 RETURN n")
Movie getMovieFromId(Integer idOfMovie);
// returns the nodes which have a title according to the movieTitle parameter
@Query("MATCH (movie:Movie {title={0}}) RETURN movie")
@Query("MATCH (movie:Movie {title=$0}) RETURN movie")
Movie getMovieFromTitle(String movieTitle);
// same with optional result
@Query("MATCH (movie:Movie {title={0}}) RETURN movie")
@Query("MATCH (movie:Movie {title=$0}) RETURN movie")
Optional<Movie> getMovieFromTitle(String movieTitle);
// returns a Page of Actors that have a ACTS_IN relationship to the movie node with the title equal to movieTitle parameter.
@Query(value = "MATCH (movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN actor", countQuery= "MATCH (movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN count(actor)")
@Query(value = "MATCH (movie:Movie {title=$0})<-[:ACTS_IN]-(actor) RETURN actor", countQuery= "MATCH (movie:Movie {title=$0})<-[:ACTS_IN]-(actor) RETURN count(actor)")
Page<Actor> getActorsThatActInMovieFromTitle(String movieTitle, PageRequest page);
// returns a Page of Actors that have a ACTS_IN relationship to the movie node with the title equal to movieTitle parameter with an accurate total count
@Query(value = "MATCH (movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN actor", countQuery = "MATCH (movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN count(*)")
@Query(value = "MATCH (movie:Movie {title=$0})<-[:ACTS_IN]-(actor) RETURN actor", countQuery = "MATCH (movie:Movie {title=$0})<-[:ACTS_IN]-(actor) RETURN count(*)")
Page<Actor> getActorsThatActInMovieFromTitle(String movieTitle, Pageable page);
// returns a Slice of Actors that have a ACTS_IN relationship to the movie node with the title equal to movieTitle parameter.
@Query("MATCH (movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN actor")
@Query("MATCH (movie:Movie {title=$0})<-[:ACTS_IN]-(actor) RETURN actor")
Slice<Actor> getActorsThatActInMovieFromTitle(String movieTitle, Pageable page);
// returns users who rated a movie (movie parameter) higher than rating (rating parameter)
@Query("MATCH (movie:Movie)<-[r:RATED]-(user) " +
"WHERE id(movie)={movieId} AND r.stars > {rating} " +
"WHERE id(movie)=$movieId AND r.stars > {rating} " +
"RETURN user")
Iterable<User> getUsersWhoRatedMovieFromTitle(@Param("movieId") Movie movie, @Param("rating") Integer rating);
// returns users who rated a movie based on movie title (movieTitle parameter) higher than rating (rating parameter)
@Query("MATCH (movie:Movie {title:{0}})<-[r:RATED]-(user) " +
"WHERE r.stars > {1} " +
@Query("MATCH (movie:Movie {title:$0})<-[r:RATED]-(user) " +
"WHERE r.stars > $1 " +
"RETURN user")
Iterable<User> getUsersWhoRatedMovieFromTitle(String movieTitle, Integer rating);
@@ -342,21 +342,21 @@ The parameters will be used in the order they appear in the method signature so
----
public interface PersonRepository extends Neo4jRepository<Person, Long> {
// MATCH (person:Person {name={0}}) RETURN person
// MATCH (person:Person {name=$0}) RETURN person
Person findByName(String name);
// MATCH (person:Person)
// WHERE person.age = {0} AND person.married = {1}
// WHERE person.age = $0 AND person.married = $1
// RETURN person
Iterable<Person> findByAgeAndMarried(int age, boolean married);
// MATCH (person:Person)
// WHERE person.age = {0}
// RETURN person ORDER BY person.name SKIP {skip} LIMIT {limit}
// WHERE person.age = $0
// RETURN person ORDER BY person.name SKIP $skip LIMIT $limit
Page<Person> findByAge(int age, Pageable pageable);
// MATCH (person:Person)
// WHERE person.age = {0}
// WHERE person.age = $0
// RETURN person ORDER BY person.name
List<Person> findByAge(int age, Sort sort);
@@ -388,7 +388,7 @@ Please keep in mind that Java and Cypher are case-sensitive.
public interface MovieRepository extends Neo4jRepository<Movie, Long> {
@Query("MATCH (movie:Movie)-[r:RATING]->(), (movie)<-[:ACTS_IN]-(actor:Actor) " +
"WHERE movie.id={0} " +
"WHERE movie.id=$0 " +
"RETURN movie as movie, COLLECT(actor) AS cast, AVG(r.stars) AS averageRating")
MovieData getMovieData(String movieId);
}