|
此版本仍在开发中，尚不被认为是稳定的。对于最新的稳定版本，请使用 Spring Data Neo4j 7.5.2！ |
自定义查询
Spring Data Neo4j与所有其他Spring Data模块一样，允许您在存储库中指定自定义查询。 如果您无法通过派生查询函数表达查找器逻辑，这些会派上用场。
由于 Spring Data Neo4j 在后台高度面向记录，因此牢记这一点很重要，不要为同一“根节点”构建包含多个记录的结果集。
| 请查看常见问题解答，了解使用存储库自定义查询的替代形式，尤其是 如何将自定义查询与自定义映射一起使用：自定义查询和自定义映射。 |
具有关系的查询
谨防笛卡尔积
假设您有一个像MATCH (m:Movie{title: 'The Matrix'})←[r:ACTED_IN]-(p:Person) return m,r,p这会导致如下所示：
+------------------------------------------------------------------------------------------+
| m | r | p |
+------------------------------------------------------------------------------------------+
| (:Movie) | [:ACTED_IN {roles: ["Emil"]}] | (:Person {name: "Emil Eifrem"}) |
| (:Movie) | [:ACTED_IN {roles: ["Agent Smith"]}] | (:Person {name: "Hugo Weaving}) |
| (:Movie) | [:ACTED_IN {roles: ["Morpheus"]}] | (:Person {name: "Laurence Fishburne"}) |
| (:Movie) | [:ACTED_IN {roles: ["Trinity"]}] | (:Person {name: "Carrie-Anne Moss"}) |
| (:Movie) | [:ACTED_IN {roles: ["Neo"]}] | (:Person {name: "Keanu Reeves"}) |
+------------------------------------------------------------------------------------------+
映射的结果很可能无法使用。
如果这将被映射到列表中，它将包含Movie但这部电影只会有一段关系。
获取每个根节点一条记录
要取回正确的对象，需要收集查询中的关系和相关节点：MATCH (m:Movie{title: 'The Matrix'})←[r:ACTED_IN]-(p:Person) return m,collect(r),collect(p)
+------------------------------------------------------------------------+ | m | collect(r) | collect(p) | +------------------------------------------------------------------------+ | (:Movie) | [[:ACTED_IN], [:ACTED_IN], ...]| [(:Person), (:Person),...] | +------------------------------------------------------------------------+
将此结果作为单个记录，Spring Data Neo4j 可以将所有相关节点正确添加到根节点。
深入图表
上面的示例假设您只尝试获取相关节点的第一级。 这有时还不够，并且图中可能有更深的节点也应该是映射实例的一部分。 有两种方法可以实现此目的：数据库端或客户端缩减。
为此，上面的示例还应包含Movies在Persons与初始Movie.
数据库端缩减
请记住，Spring Data Neo4j 只能正确处理基于记录，一个实体实例的结果需要在一条记录中。 使用 Cypher 的路径功能是获取图中所有分支的有效选项。
MATCH p=(m:Movie{title: 'The Matrix'})<-[:ACTED_IN]-(:Person)-[:ACTED_IN*..0]->(:Movie)
RETURN p;这将导致多个路径未合并在一条记录中。
可以调用collect(p)但 Spring Data Neo4j 不理解映射过程中路径的概念。
因此，需要提取节点和关系以获得结果。
MATCH p=(m:Movie{title: 'The Matrix'})<-[:ACTED_IN]-(:Person)-[:ACTED_IN*..0]->(:Movie)
RETURN m, nodes(p), relationships(p);因为从《黑客帝国》到另一部电影有多条路径，所以结果仍然不会是一张唱片。 这就是 Cypher 的 reduce 函数发挥作用的地方。
MATCH p=(m:Movie{title: 'The Matrix'})<-[:ACTED_IN]-(:Person)-[:ACTED_IN*..0]->(:Movie)
WITH collect(p) as paths, m
WITH m,
reduce(a=[], node in reduce(b=[], c in [aa in paths | nodes(aa)] | b + c) | case when node in a then a else a + node end) as nodes,
reduce(d=[], relationship in reduce(e=[], f in [dd in paths | relationships(dd)] | e + f) | case when relationship in d then d else d + relationship end) as relationships
RETURN m, relationships, nodes;这reduce函数允许我们从各种路径中展平节点和关系。
因此，我们将得到一个类似于每个根节点获取一条记录的元组，但集合中混合了关系类型或节点。
客户端减少
如果减少应该在客户端进行，Spring Data Neo4j还使您能够映射关系或节点列表的列表。 尽管如此，要求仍然适用返回的记录应包含所有信息，以正确水合生成的实体实例。
MATCH p=(m:Movie{title: 'The Matrix'})<-[:ACTED_IN]-(:Person)-[:ACTED_IN*..0]->(:Movie)
RETURN m, collect(nodes(p)), collect(relationships(p));附加的collect语句以以下格式创建列表：
[[rel1, rel2], [rel3, rel4]]
这些列表现在将在映射过程中转换为平面列表。
决定是否要使用客户端或数据库端缩减取决于将生成的数据量。
当reduce函数。
另一方面，需要在客户端合并的大量数据会导致更高的内存使用率。 |
使用路径填充和返回实体列表
给定的是一个如下图：
以及映射中所示的域模型（为简洁起见，省略了构造函数和访问器）：
@Node
public class SomeEntity {
@Id
private final Long number;
private String name;
@Relationship(type = "SOME_RELATION_TO", direction = Relationship.Direction.OUTGOING)
private Set<SomeRelation> someRelationsOut = new HashSet<>();
}
@RelationshipProperties
public class SomeRelation {
@RelationshipId
private Long id;
private String someData;
@TargetNode
private SomeEntity targetPerson;
}如您所见，这些关系只是外向的。生成的查找器方法（包括findById） 将始终尝试匹配
要映射的根节点。从那时起，所有相关对象都将被映射。在应仅返回一个对象的查询中，
返回该根对象。在返回多个对象的查询中，将返回所有匹配的对象。传入关系
当然，从返回的那些对象中填充。
假设以下 Cypher 查询：
MATCH p = (leaf:SomeEntity {number: $a})-[:SOME_RELATION_TO*]-(:SomeEntity)
RETURN leaf, collect(nodes(p)), collect(relationships(p))它遵循每个根节点获取一条记录的建议，并且非常适合叶节点 你想在这里匹配。但是：这仅在返回 0 或 1 个映射对象的所有方案中都是如此。 虽然该查询将像以前一样填充所有关系，但它不会返回所有 4 个对象。
这可以通过返回整个路径来更改：
MATCH p = (leaf:SomeEntity {number: $a})-[:SOME_RELATION_TO*]-(:SomeEntity)
RETURN p在这里，我们确实想使用路径p实际上返回 3 行，其中包含所有 4 个节点的路径。所有 4 个节点都将
填充、链接在一起并返回。
自定义查询中的参数
执行此作的方式与在 Neo4j 浏览器或 Cypher-Shell 中发出的标准 Cypher 查询完全相同，
使用语法（从 Neo4j 4.0 开始，旧的$${foo}Cypher 参数的语法已从数据库中删除）。
public interface ARepository extends Neo4jRepository<AnAggregateRoot, String> {
@Query("MATCH (a:AnAggregateRoot {name: $name}) RETURN a") (1)
Optional<AnAggregateRoot> findByCustomQuery(String name);
}| 1 | 在这里，我们用它的名称来指代参数。
您还可以使用$0等等。 |
您需要使用-parameters使命名参数无需进一步注释即可工作。
Spring Boot Maven 和 Gradle 插件会自动为您执行此作。
如果由于任何原因这不可行，您可以添加@Param并显式指定名称或使用参数索引。 |
映射的实体（所有带有@Node） 作为参数传递给带有
自定义查询将转换为嵌套映射。
以下示例将结构表示为 Neo4j 参数。
给定的是Movie,Vertex和Actor类注释，如电影模型所示：
@Node
public final class Movie {
@Id
private final String title;
@Property("tagline")
private final String description;
@Relationship(value = "ACTED_IN", direction = Direction.INCOMING)
private final List<Actor> actors;
@Relationship(value = "DIRECTED", direction = Direction.INCOMING)
private final List<Person> directors;
}
@Node
public final class Person {
@Id @GeneratedValue
private final Long id;
private final String name;
private Integer born;
@Relationship("REVIEWED")
private List<Movie> reviewed = new ArrayList<>();
}
@RelationshipProperties
public final class Actor {
@RelationshipId
private final Long id;
@TargetNode
private final Person person;
private final List<String> roles;
}
interface MovieRepository extends Neo4jRepository<Movie, String> {
@Query("MATCH (m:Movie {title: $movie.__id__})\n"
+ "MATCH (m) <- [r:DIRECTED|REVIEWED|ACTED_IN] - (p:Person)\n"
+ "return m, collect(r), collect(p)")
Movie findByMovie(@Param("movie") Movie movie);
}传递Movie到上面的 repository 方法，将生成以下 Neo4j map 参数：
{
"movie": {
"__labels__": [
"Movie"
],
"__id__": "The Da Vinci Code",
"__properties__": {
"ACTED_IN": [
{
"__properties__": {
"roles": [
"Sophie Neveu"
]
},
"__target__": {
"__labels__": [
"Person"
],
"__id__": 402,
"__properties__": {
"name": "Audrey Tautou",
"born": 1976
}
}
},
{
"__properties__": {
"roles": [
"Sir Leight Teabing"
]
},
"__target__": {
"__labels__": [
"Person"
],
"__id__": 401,
"__properties__": {
"name": "Ian McKellen",
"born": 1939
}
}
},
{
"__properties__": {
"roles": [
"Dr. Robert Langdon"
]
},
"__target__": {
"__labels__": [
"Person"
],
"__id__": 360,
"__properties__": {
"name": "Tom Hanks",
"born": 1956
}
}
},
{
"__properties__": {
"roles": [
"Silas"
]
},
"__target__": {
"__labels__": [
"Person"
],
"__id__": 403,
"__properties__": {
"name": "Paul Bettany",
"born": 1971
}
}
}
],
"DIRECTED": [
{
"__labels__": [
"Person"
],
"__id__": 404,
"__properties__": {
"name": "Ron Howard",
"born": 1954
}
}
],
"tagline": "Break The Codes",
"released": 2006
}
}
}节点由映射表示。地图将始终包含__id__这是映射的 id 属性。
下__labels__所有标签，静态和动态，都将可用。
所有属性和关系类型都显示在这些映射中，就像实体在图中显示时一样
已由 SDN 编写。
值将具有正确的 Cypher 类型，不需要进一步转换。
所有关系都是映射列表。动态关系将相应地解决。
一对一关系也将序列化为单例列表。因此，要访问一对一映射
在人与人之间，你会写这个 das$person.__properties__.BEST_FRIEND[0].__target__.__id__. |
如果一个实体与不同类型的其他节点具有相同类型的关系，则它们都将显示在同一列表中。 如果您需要这样的映射并且还需要使用这些自定义参数，则必须相应地展开它。 一种方法是相关子查询（需要 Neo4j 4.1+）。
自定义查询中的值表达式
自定义查询中的 Spring 表达式语言
Spring 表达式语言 （SpEL） 可用于内部的自定义查询:#{}.
这里的冒号指的是一个参数，这样的表达式应该在参数有意义的地方使用。
但是，当使用我们的文字扩展时，您可以在标准 Cypher
不允许参数（例如标签或关系类型）。
这是在经过 SpEL 评估的查询中定义文本块的标准 Spring Data 方法。
下面的示例基本上定义了与上述相同的查询，但使用了WHERE避免更多大括号的子句：
public interface ARepository extends Neo4jRepository<AnAggregateRoot, String> {
@Query("MATCH (a:AnAggregateRoot) WHERE a.name = :#{#pt1 + #pt2} RETURN a")
Optional<AnAggregateRoot> findByCustomQueryWithSpEL(String pt1, String pt2);
}SpEL 阻塞的开头为:#{然后引用给定的String按名称命名的参数 （#pt1).
不要将其与上面的 Cypher 语法混淆！
SpEL 表达式将这两个参数连接成一个值，该值最终传递给 appendix/neo4j-client.adoc#neo4j-client。
SpEL 块以 结尾。}
SpEL 还解决了另外两个问题。我们提供了两个扩展，允许传入Sortobject 转换为自定义查询。
还记得自定义查询中的 faq.adoc#custom-queries-with-page-and-slice-examples 吗？
使用orderBy扩展名，您可以传入Pageable使用动态排序到自定义查询：
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.neo4j.repository.Neo4jRepository;
import org.springframework.data.neo4j.repository.query.Query;
public interface MyPersonRepository extends Neo4jRepository<Person, Long> {
@Query(""
+ "MATCH (n:Person) WHERE n.name = $name RETURN n "
+ ":#{orderBy(#pageable)} SKIP $skip LIMIT $limit" (1)
)
Slice<Person> findSliceByName(String name, Pageable pageable);
@Query(""
+ "MATCH (n:Person) WHERE n.name = $name RETURN n :#{orderBy(#sort)}" (2)
)
List<Person> findAllByName(String name, Sort sort);
}| 1 | 一个Pageable一直有名字pageable在 SpEL 上下文中。 |
| 2 | 一个Sort一直有名字sort在 SpEL 上下文中。 |
Spring 表达式语言扩展
文字扩展
这literal扩展可用于在自定义查询中使标签或关系类型等内容“动态”。
标签和关系类型都不能在 Cypher 中参数化，因此必须给出文字。
interface BaseClassRepository extends Neo4jRepository<Inheritance.BaseClass, Long> {
@Query("MATCH (n:`:#{literal(#label)}`) RETURN n") (1)
List<Inheritance.BaseClass> findByLabel(String label);
}| 1 | 这literal扩展名将替换为评估参数的文字值。 |
在这里，literalvalue 已用于在标签上动态匹配。
如果您通过SomeLabel作为该方法的参数，MATCH (n:将生成。添加了刻度以正确转义值。SDN 不会这样做
对你来说，因为这可能不是你在所有情况下都想要的。SomeLabel) RETURN n
列表扩展
对于多个值，有allOf和anyOf在适当的位置，这将呈现
a 或&|所有值的串联列表。
interface BaseClassRepository extends Neo4jRepository<Inheritance.BaseClass, Long> {
@Query("MATCH (n:`:#{allOf(#label)}`) RETURN n")
List<Inheritance.BaseClass> findByLabels(List<String> labels);
@Query("MATCH (n:`:#{anyOf(#label)}`) RETURN n")
List<Inheritance.BaseClass> findByLabels(List<String> labels);
}参考标签
你已经知道如何将 Node 映射到域对象：
@Node(primaryLabel = "Bike", labels = {"Gravel", "Easy Trail"})
public class BikeNode {
@Id String id;
String name;
}这个节点有几个标签，在自定义查询中一直重复它们很容易出错：你可能
忘记一个或打错字。我们提供以下表达式来缓解这种情况：#{#staticLabels}.请注意，这个不是以冒号开头的！您可以在用@Query:
#{#staticLabels}在行动public interface BikeRepository extends Neo4jRepository<Bike, String> {
@Query("MATCH (n:#{#staticLabels}) WHERE n.id = $nameOrId OR n.name = $nameOrId RETURN n")
Optional<Bike> findByNameOrId(@Param("nameOrId") String nameOrId);
}此查询将解析为
MATCH (n:`Bike`:`Gravel`:`Easy Trail`) WHERE n.id = $nameOrId OR n.name = $nameOrId RETURN n请注意我们如何使用标准参数nameOrId：在大多数情况下，没有必要在这里复杂化
添加 SpEL 表达式。