Cypher（Neo4j）：读取树结构在具有特定属性的节点处停止

Question

我有一个像这样的树结构：

每个节点都具有id属性，例如“ root”，“ child0”等，以及expanded属性意味着当前分支已扩展，即在查询时应包括其子节点。

因此，我需要编写Cypher查询，该查询将从具有指定id的节点开始，读取其所有子节点，这些子节点在叶子处停止，并且节点的expanded属性设置为false 。

结果应为树状形式，因此我不需要进一步处理。

我尝试了类似的东西

MATCH (n:Node { id: 'root' }),
      paths = (n)<-[:CHILD_OF*]-(children:Node { expanded: true })
RETURN collect(nodes(paths))

但是随后我得到了“深度优先”路径（带有大量重复的信息），我需要对其进行后期处理以从中取出一棵树。 而且我无法执行此操作，因为它不包含子项的订购信息（ NEXT_SIBLING_OF属性用于什么）。

在Cypher中是否有惯用的方式来完成此任务，还是应该回退以编写不受管的扩展程序？

Answer 1

到目前为止，我已经使用非托管扩展实现了我需要的东西，看起来几乎不可能在Cypher中正确，快速地完成它。

package io.treev.treegraph.neo.extension;

import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.map.ObjectMapper;
import org.neo4j.graphdb.*;
import org.neo4j.graphdb.traversal.TraversalDescription;
import org.neo4j.helpers.collection.IteratorUtil;

import javax.ws.rs.GET;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.StreamingOutput;
import java.io.IOException;
import java.util.Optional;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

@javax.ws.rs.Path("/")
public class TreeGraphResource {

  private final GraphDatabaseService db;
  private final ObjectMapper objectMapper;

  public TreeGraphResource(@Context GraphDatabaseService graphDb) {
    this.db = graphDb;
    this.objectMapper = new ObjectMapper();
  }

  @GET
  @javax.ws.rs.Path("/{nodeId}")
  @Produces(MediaType.APPLICATION_JSON)
  public Response readTree(@PathParam("nodeId") String nodeId) {
    StreamingOutput stream = output -> {
      JsonGenerator jg = objectMapper.getJsonFactory().createJsonGenerator(output, JsonEncoding.UTF8);

      try (Transaction ignore = db.beginTx()) {
        Node node = getNode(nodeId);
        buildNode(node, jg);
      }

      jg.flush();
      jg.close();
    };

    return Response.ok().entity(stream).type(MediaType.APPLICATION_JSON).build();
  }

  private static final String TREE_NODE_LABEL = "TreeNode";

  private static final String ID_PROPERTY = "id";
  private static final String EXPANDED_PROPERTY = "expanded";
  private static final String CHILDREN_PROPERTY = "children";

  private static final DynamicRelationshipType CHILD_OF_REL =
    DynamicRelationshipType.withName("CHILD_OF");
  private static final DynamicRelationshipType NEXT_SIBLING_OF_REL =
    DynamicRelationshipType.withName("NEXT_SIBLING_OF");

  private Node getNode(String nodeId) {
    return db.findNode(DynamicLabel.label(TREE_NODE_LABEL), ID_PROPERTY, nodeId);
  }

  private void buildNode(Node node, JsonGenerator jg) {
    try {
      jg.writeStartObject();

      jg.writeFieldName(ID_PROPERTY);
      jg.writeString((String) node.getProperty(ID_PROPERTY));

      Optional<Boolean> expandedOpt = isExpanded(node);
      if (expandedOpt.isPresent()) {
        boolean expanded = expandedOpt.get();

        jg.writeFieldName(EXPANDED_PROPERTY);
        jg.writeBoolean(expanded);

        if (!expanded) {
          int childrenCount = countChildren(node);

          if (childrenCount > 0) {
            jg.writeFieldName("childrenCount");
            jg.writeNumber(childrenCount);
          }
        }
      }

      if (!expandedOpt.isPresent() || expandedOpt.get()) {
        Stream<Node> children = getChildren(node);

        if (children != null) {
          jg.writeFieldName(CHILDREN_PROPERTY);
          jg.writeStartArray();

          children.forEach(child -> buildNode(child, jg));

          jg.writeEndArray();
        }
      }

      jg.writeEndObject();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  private Stream<Node> getChildren(Node node) {
    if (node != null) {
      Optional<Node> firstChildOpt = getFirstChild(node);

      return firstChildOpt.map(firstChild -> {
        TraversalDescription traversal =
          db.traversalDescription().depthFirst().relationships(NEXT_SIBLING_OF_REL, Direction.INCOMING);

        return StreamSupport.stream(traversal.traverse(firstChild).spliterator(), false).map(Path::endNode);
      }).orElse(null);

    } else {
      return null;
    }
  }

  private Optional<Node> getFirstChild(Node node) {
    Iterable<Relationship> childrenRelations = node.getRelationships(CHILD_OF_REL, Direction.INCOMING);

    return StreamSupport.stream(childrenRelations.spliterator(), false)
      .map(Relationship::getStartNode)
      .filter(relationship -> !relationship.hasRelationship(NEXT_SIBLING_OF_REL, Direction.OUTGOING))
      .findFirst();
  }

  private int countChildren(Node node) {
    if (node != null) {
      return IteratorUtil.count(node.getRelationships(CHILD_OF_REL, Direction.INCOMING));
    } else {
      return 0;
    }
  }

  private Optional<Boolean> isExpanded(Node node) {
    Boolean expanded = (Boolean) node.getProperty(EXPANDED_PROPERTY, null);
    return Optional.ofNullable(expanded);
  }

}

响应示例：

{
  "id": "root",
  "expanded": true,
  "children": [
    {
      "id": "child10"
    },
    {
      "id": "child0"
    },
    {
      "id": "child1",
      "expanded": true,
      "children": [
        {
          "id": "child2",
          "expanded": false,
          "childrenCount": 1
        },
        {
          "id": "child3"
        },
        {
          "id": "child4"
        }
      ]
    }
  ]
}