java neo4j检查是否存在关系

Question

如果这是重复的，则排除，尽管目前为止我没有找到答案。

我有一个应用程序通过cypher语句针对REST-API创建节点和关系。我创建关系与下面的代码：

public URI createRelationship(GraphNodeTypes sourceType, URI sourceNode, 
         GraphNodeTypes targetType, URI targetNode, 
    GraphRelationshipTypes relationshipType, String[] jsonAttributes) { 
URI relationShipLocation = null; 

String cypherArt = getNodeIdFromLocation(sourceNode)+"-[:"+relationshipType+"]->"+getNodeIdFromLocation(targetNode); 

logger.info("creating relationship ({}:{}) -[:{}]-> ({}:{})", 
           sourceType, 
           getNodeIdFromLocation(sourceNode), 
           relationshipType, 
           targetType, 
           getNodeIdFromLocation(targetNode)); 

try { 
    URI finalUrl = new URI(sourceNode.toString() + "/relationships"); 
    String cypherStatement = generateJsonRelationship(targetNode, 
                 relationshipType, 
                 jsonAttributes); 

    logger.trace("sending CREATE RELATIONSHIP cypher as {} to endpoint {}", cypherStatement, finalUrl); 
    WebResource resource = Client.create().resource(finalUrl); 

    ClientResponse response = resource 
      .accept(MediaType.APPLICATION_JSON) 
      .type(MediaType.APPLICATION_JSON) 
      .entity(cypherStatement) 
      .post(ClientResponse.class); 

    String responseEntity = response.getEntity(String.class).toString(); 
    int responseStatus = response.getStatus(); 

    logger.trace("POST to {} returned status code {}, returned data: {}", 
      finalUrl, responseStatus, 
      responseEntity); 

    // first check if the http code was ok 
    HttpStatusCodes httpStatusCodes = HttpStatusCodes.getHttpStatusCode(responseStatus); 
    if (!httpStatusCodes.isOk()){ 
     if (httpStatusCodes == HttpStatusCodes.FORBIDDEN){ 
      logger.error(HttpErrorMessages.getHttpErrorText(httpStatusCodes.getErrorCode())); 
     } else { 
      logger.error("Error {} sending data to {}: {} ", response.getStatus(), finalUrl, HttpErrorMessages.getHttpErrorText(httpStatusCodes.getErrorCode())); 
     } 
    } else { 
     JSONParser reponseParser = new JSONParser(); 
     Object responseObj = reponseParser.parse(responseEntity); 
     JSONObject jsonResponseObj = responseObj instanceof JSONObject ?(JSONObject) responseObj : null; 
     if(jsonResponseObj == null) 
      throw new ParseException(0, "returned json object is null"); 

     //logger.trace("returned response object is {}", jsonResponseObj.toString()); 
     try { 
      relationShipLocation = new URI((String)((JSONObject)((JSONArray)((JSONObject)((JSONArray)((JSONObject)((JSONArray)jsonResponseObj.get("results")).get(0)).get("data")).get(0)).get("rest")).get(0)).get("self")); 
     } catch (Exception e) { 
      logger.warn("CREATE RELATIONSHIP statement did not return a self object, returning null -- error was {}", e.getMessage()); 
      relationShipLocation = null; 
     } 
    } 
} catch (Exception e) { 
    logger.error("could not create relationship "); 
} 
return relationShipLocation; 
} 

private static String generateJsonRelationship(URI endNode, 
    GraphRelationshipTypes relationshipType, String[] jsonAttributes) { 
StringBuilder sb = new StringBuilder(); 
sb.append("{ \"to\" : \""); 
sb.append(endNode.toString()); 
sb.append("\", "); 

sb.append("\"type\" : \""); 
sb.append(relationshipType.toString()); 
if (jsonAttributes == null || jsonAttributes.length < 1){ 
    sb.append("\""); 
} else { 
    sb.append("\", \"data\" : "); 
    for (int i = 0; i < jsonAttributes.length; i++) { 
     sb.append(jsonAttributes[i]); 
     if (i < jsonAttributes.length - 1){ 
      // Miss off the final comma 
      sb.append(", "); 
     } 
    } 
} 

sb.append(" }"); 
return sb.toString(); 
} 

我的问题是，我想检查是否给定类型的给定关系的两个节点之间已经存在PRIOR创建它。

有人可以告诉我，如何查询关系？

随着节点我不喜欢这样的搭配：

MATCH cypher {"statements": [ {"statement": "MATCH (p:SOCIALNETWORK {sn_id: 'TW'}) RETURN p", "resultDataContents":["REST"]} ] } 

对端点

http://localhost:7474/db/data/transaction/<NUMBER> 

我将如何构建，检查是否有关系的声明，节点6和5或任何之间说？

由于提前，

克里斯

Answer 1

你可能要考虑通过暗号这样做，并使用MERGE/ON CREATE/ON MATCH关键字。

例如，你可以做这样的事情：

create (a:Person {name: "Bob"})-[:knows]->(b:Person {name: "Susan"}); 

MATCH (a:Person {name: "Bob"}), (b:Person {name: "Susan"}) 
MERGE (a)-[r:knows]->(b) 
ON CREATE SET r.alreadyExisted=false 
ON MATCH SET r.alreadyExisted=true 
RETURN r.alreadyExisted; 

这MATCH/MERGE查询，我在这里提供将返回true或false，这取决于关系是否已经存在与否。

另外，FWIW它看起来像你用来通过StringBuilder累积JSON的代码很可能会很笨重和容易出错。有很多优秀的库，如Google GSON可以为你做JSON，所以你可以创建JSON对象，数组，基元等等 - 然后让库担心将它正确序列化为一个字符串。这往往会使你的代码变得更清洁，更容易维护，当你把你的JSON格式化（我们都这么做）的东西搞砸时，比你累积字符串更容易找到。

Answer 2

在Java

Relationship getRelationshipBetween(Node n1, Node n2) { // RelationshipType type, Direction direction 
    for (Relationship rel : n1.getRelationships()) { // n1.getRelationships(type,direction) 
     if (rel.getOtherNode(n1).equals(n2)) return rel; 
    } 
    return null; 
}