我使用Spring-Data和SpringBoot来填充我的Neo4j图形数据库。
我定义了以下Neo4j实体：
Source实体 - ＆gt;
@NodeEntity
public class Source implements Comparable<Source> {
@GraphId private Long id;
private String name;
private SourceType type;
private String dataStoreName;
private String dataStoreDesc;
private Source() {
// Empty constructor required as of Neo4j API 2.0.5
};
public Source(String name, SourceType type, String dataStoreName, String dataStoreDesc) {
this.name = name;
this.type = type;
this.dataStoreName = dataStoreName;
this.dataStoreDesc = dataStoreDesc;
}
@Relationship(type = "CONTAINS", direction = Relationship.UNDIRECTED)
public Set<Field> fields;
public void contains(Field field) {
if (fields == null) {
fields = new HashSet<Field>();
}
fields.add(field);
}
/* Getter and Setters */
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public SourceType getType() {
return type;
}
public void setType(SourceType type) {
this.type = type;
}
public String getDataStoreName() {
return dataStoreName;
}
public void setDataStoreName(String dataStoreName) {
this.dataStoreName = dataStoreName;
}
public String getDataStoreDesc() {
return dataStoreDesc;
}
public void setDataStoreDesc(String dataStoreDesc) {
this.dataStoreDesc = dataStoreDesc;
}
public Set<Field> getFields() {
return fields;
}
public void setFields(Set<Field> fields) {
this.fields = fields;
}
@Override
public int compareTo(Source other) {
String name = other.getName();
SourceType type = other.getType();
if(this.name.equalsIgnoreCase(name) && this.type.equals(type))
return 0;
return -1;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((type == null) ? 0 : type.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Source other = (Source) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (type != other.type)
return false;
return true;
}
}
Field实体 - ＆gt;
@NodeEntity
public class Field implements Comparable<Field> {
@GraphId private Long id;
private String name;
private FieldType fieldType;
private SourceType sourceType;
private String logicalName;
private String dataType;
private String dataSize;
private String description;
private Field() {
// Empty constructor required as of Neo4j API 2.0.5
};
public Field(String name, FieldType fieldType, SourceType sourceType, String logicalName, String dataType, String dataSize, String description) {
this.name = name;
this.fieldType = fieldType;
this.sourceType = sourceType;
this.logicalName = logicalName;
this.dataType = dataType;
this.dataSize = dataSize;
this.description = description;
}
@Relationship(type = "MAPS-TO", direction = Relationship.UNDIRECTED)
public Set<Field> fields;
public void mapsTo(Field field) {
if (fields == null) {
fields = new HashSet<Field>();
}
fields.add(field);
}
/* Getter and Setters */
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public FieldType getFieldType() {
return fieldType;
}
public void setFieldType(FieldType fieldType) {
this.fieldType = fieldType;
}
public SourceType getSourceType() {
return sourceType;
}
public void setSourceType(SourceType sourceType) {
this.sourceType = sourceType;
}
public String getLogicalName() {
return logicalName;
}
public void setLogicalName(String logicalName) {
this.logicalName = logicalName;
}
public String getDataType() {
return dataType;
}
public void setDataType(String dataType) {
this.dataType = dataType;
}
public String getDataSize() {
return dataSize;
}
public void setDataSize(String dataSize) {
this.dataSize = dataSize;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Set<Field> getFields() {
return fields;
}
public void setFields(Set<Field> fields) {
this.fields = fields;
}
@Override
public int compareTo(Field other) {
String name = other.getName();
FieldType fieldType = other.getFieldType();
SourceType sourceType = other.getSourceType();
if(this.name.equalsIgnoreCase(name) && this.fieldType.equals(fieldType) && this.sourceType.equals(sourceType))
return 0;
return -1;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((fieldType == null) ? 0 : fieldType.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((sourceType == null) ? 0 : sourceType.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Field other = (Field) obj;
if (fieldType != other.fieldType)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (sourceType != other.sourceType)
return false;
return true;
}
}
所以，Source CONTAINS多个Field。 Field MAPS-TO是一个或多个其他Field。
每个Source都是SourceType。
我的不同SourceType是：生产者，入境者，分阶段，中间人，出境者，消费者。
public enum SourceType {
PRODUCER, INBOUND, STAGING, INTERMEDIATE, OUTBOUND, CONSUMER;
}
每个Field都是FieldType。
我的不同FieldType是：FILE_FIELD，DB_COLUMN。
public enum FieldType {
FILE_FIELD, DB_COLUMN;
}
我的数据沿袭如下： 生产者 - ＆gt; INBOUND - ＆gt;分段 - ＆gt;中间 - ＆gt; OUTBOUND - ＆gt; CONSUMER
我现在正在寻找一个高级的Cypher查询，如果我在消费者Field中提供Source，我就可以跟踪后面的 em>直到生产者Source。
同样，我也在寻找一个查询，通过该查询，如果我在生产者Field中提供Source，我就可以跟踪其血统前进直到消费者Source。
我已尝试使用shortestPath和neighbors函数构建查询，但它似乎无法提取我正在寻找的结果。
任何建议/指示都将不胜感激。
提前致谢！
UPDATE-1
我的数据沿袭背景：
我的应用程序从外部应用程序（PRODUCE）获取文件。
我知道外部应用程序的数据库表/列填充了文件中的字段。
所以在这里，PRODUCER将是我的Source节点;外部应用程序的每个table.column（填充文件）是Field节点，PRODUCER Source节点与所有CONTAINS节点（表示表）具有Field关系。填充文件的外部应用程序数据库表的列。）
来自外部应用程序的文件称为INBOUND。它是逗号分隔的文件。
我知道文件中的字段名称是什么，以及顺序是什么。
所以在这里，INBOUND将是我的Source节点;文件中的每个字段都是Field节点，INBOUND Source节点与所有CONTAINS节点（表示入站文件中的文件字段）具有Field关系。
此外，INBOUND Field的每个Source节点与生产者MAPS_TO的{{1}}节点都具有Field关系（一对一映射）。
继续进行类似的工作流程，我的下一个阶段称为STAGING，其中我将入站文件字段加载到我的数据库表/列中。
所以这里，STAGING将是我的Source节点，数据库表的每一列（我加载文件字段）将代表Source节点。
STAGING Source节点将与所有Field节点（表示我加载文件字段的db表的db table.column）具有CONTAINS关系。
此外，STAGING Field的每个Field节点都与INBOUND Source的{{1}}节点具有MAPS_TO关系（一对一映射）。
类似我的下一阶段是INTERMEDIATE。在这个阶段，我查询加载输入文件字段的表，然后将输出刷新到另一个文件中（根据我的业务用例，我可能选择查询全部或仅查询表列的一部分）从输入文件填充的）。
我知道哪些字段以及将以何种顺序进入我的INTERMEDIATE文件。
所以在这里，INTERMEDIATE是我的Field节点，进入INTERMEDIATE文件的每个字段代表我的Source节点。 INTERMEDIATE Source与表示中间文件中字段的所有Field节点之间也会有Source个关系。
此外，这些CONTAINS节点中的每个节点都与STAGING Source（一对一映射）字段具有Field的关系。
同样，我是OUTBOUND阶段，最后是消费阶段。
......（我希望你现在能够看到血统）
我的查询的目标是，如果我提供Field名称（代表PRODUCER的table.column）作为输入，那么我应该能够追踪它的血统，直到消费者（即，我的血统的最后阶段）。
答案 0 :(得分：0)
同样，我也在寻找一个查询，通过该查询，如果我在生产者
Field中提供Source，我就可以跟踪其血统前进直到消费者Source。
我认为我完全不了解您的数据模型＆amp;要求，但这是一个想法：
MATCH
(:Field {name: { fieldName } })<-[:CONTAINS]-
(:Source {type: "PRODUCER" })-[:MAPS_TO]->
(:Source {type: "INBOUND" })-[:MAPS_TO]->
(:Source {type: "STAGING" })-[:MAPS_TO]->
(:Source {type: "INTERMEDIATE"})-[:MAPS_TO]->
(:Source {type: "OUTBOUND" })-[:MAPS_TO]->
(consumer:Source {type: "CONSUMER" })
RETURN consumer
答案 1 :(得分：0)
我能够通过以下查询获得所需的数据沿袭：
MATCH (f5:Field)-[:MAPS_TO]-(f4:Field)-[:MAPS_TO]-(f3:Field)-[:MAPS_TO]-(f2:Field)-[:MAPS_TO]-(f1:Field)-[:MAPS_TO]-(f:Field)<-[:CONTAINS]-(s:Source {type: "SOURCE"}) WHERE f.name="<my input source field>" RETURN f,s,f1,f2,f3,f4,f5