Java Relationship类代码示例

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Nonnull
default String pathAsString(@Nonnull Path path) {
    List<String> list = new ArrayList<>(path.length());
    Node lastTraversed = path.start();
    if (lastTraversed != null) {
        list.add(nodeAsString(lastTraversed));

        for (Path.Segment segment : path) {
            Relationship relationship = segment.relationship();
            if (relationship.startNodeId() == lastTraversed.id()) {
                list.add("-" + relationshipAsString(relationship) + "->");
            } else {
                list.add("<-" + relationshipAsString(relationship) + "-");
            }
            list.add(nodeAsString(segment.end()));
            lastTraversed = segment.end();
        }
    }

    return list.stream().collect(Collectors.joining());
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
private Entity getPropertiesObject(long id, int rowIndex, ElemType typ) {
	Record rec = this.records.get(rowIndex);
	List<Pair<String, Value>> flds = rec.fields();
	for (Pair<String, Value> pair : flds) {
		if (typ == ElemType.NODE && pair.value() instanceof NodeValue) {
			Node nd = pair.value().asNode();
			if (nd.id() == id)
				return nd;
		} else if (typ == ElemType.RELATION && pair.value() instanceof RelationshipValue) {
			Relationship rel = pair.value().asRelationship();
			if (rel.id() == id)
				return rel;
		}
	}
	
	// element with id may not have been loaded
	return this.reloaded.getEntity(id, typ);
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Override
public PathInfo getPathInfo(String colKey) {
	PathInfo pathInfo = null;
	Value val;
	try {
		val = this.record.get(colKey);
	} catch (NoSuchRecordException e) {
		throw new RuntimeException("no result column: " + colKey);
	}
	String typName = val.type().name();
	if ("PATH".equals(typName)) {
		Path p = val.asPath();
		long startId = p.start().id();
		long endId = p.end().id();
		List<Long> relIds = new ArrayList<Long>();
		Iterator<Relationship> it = p.relationships().iterator();
		while(it.hasNext()) {
			Relationship rel = it.next();
			relIds.add(Long.valueOf(rel.id()));
		}
		pathInfo = new PathInfo(startId, endId, relIds, p);
	}
	return pathInfo;
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Test
public void shouldGetCurrentPathByGivenEntity() {
    // This is in a try-block, to make sure we close the driver after the test
    try (Driver driver = GraphDatabase
            .driver(neo4j.boltURI(), Config.build().withEncryption().toConfig()); Session session = driver.session()) {
        // Given
        session.run("CREATE (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'})");
        session.run("MATCH (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'}) CREATE (e)-[:HAS_STATE {startDate:593910000000}]->(s)");
        Node entity = session.run("MATCH (e:Entity) RETURN e").single().get("e").asNode();
        Node state = session.run("MATCH (s:State) RETURN s").single().get("s").asNode();

        // When
        StatementResult result = session.run("MATCH (e:Entity) WITH e CALL graph.versioner.get.current.path(e) YIELD path RETURN path");

        Path current = result.single().get("path").asPath();
        Iterator<Relationship> relsIterator = current.relationships().iterator();
        Map<String, Object> rels = new HashMap<>();
        while (relsIterator.hasNext()) {
            Relationship support = relsIterator.next();
            rels.put(support.type(), support);
        }

        // Then
        assertThat(current.contains(entity), equalTo(true));
        assertThat(rels.containsKey(Utility.CURRENT_TYPE), equalTo(true));
        assertThat(current.contains(state), equalTo(true));
    }
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Test
public void shouldGetAllStateNodesByGivenEntity() {
    // This is in a try-block, to make sure we close the driver after the test
    try (Driver driver = GraphDatabase
            .driver(neo4j.boltURI(), Config.build().withEncryption().toConfig()); Session session = driver.session()) {
        // Given
        session.run("CREATE (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'})");
        session.run("MATCH (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'}) CREATE (e)-[:HAS_STATE {startDate:593910000000}]->(s)");
        session.run("MATCH (e)-[hs:HAS_STATE]->(s) CREATE (e)-[:HAS_STATE {startDate: 593900000000, endDate: hs.startDate}]->(:State{key:'oldState'})");
        session.run("MATCH (s1:State {key:'oldState'}), (s2:State {key:'initialValue'}) CREATE (s1)<-[:PREVIOUS {date: 593900000000}]-(s2) ");
        Node entity = session.run("MATCH (e:Entity) RETURN e").single().get("e").asNode();
        Node stateNew = session.run("MATCH (s:State {key:'initialValue'}) RETURN s").single().get("s").asNode();
        Node stateOld = session.run("MATCH (s:State {key:'oldState'}) RETURN s").single().get("s").asNode();

        // When
        StatementResult result = session.run("MATCH (e:Entity) WITH e CALL graph.versioner.get.all(e) YIELD path RETURN path");

        Path current = result.single().get("path").asPath();
        Iterator<Relationship> relsIterator = current.relationships().iterator();
        Map<String, Object> rels = new HashMap<>();
        while (relsIterator.hasNext()) {
            Relationship support = relsIterator.next();
            rels.put(support.type(), support);
        }

        // Then
        assertThat(current.contains(entity), equalTo(true));
        assertThat(current.contains(stateNew), equalTo(true));
        assertThat(rels.containsKey(Utility.PREVIOUS_TYPE), equalTo(true));
        assertThat(current.contains(stateOld), equalTo(true));
    }
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Test
public void shouldGetAllStateNodesByGivenEntityWithOnlyOneCurrentState() {
    // This is in a try-block, to make sure we close the driver after the test
    try (Driver driver = GraphDatabase
            .driver(neo4j.boltURI(), Config.build().withEncryption().toConfig()); Session session = driver.session()) {
        // Given
        session.run("CREATE (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'})");
        session.run("MATCH (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'}) CREATE (e)-[:HAS_STATE {startDate:593910000000}]->(s)");
        Node entity = session.run("MATCH (e:Entity) RETURN e").single().get("e").asNode();
        Node stateNew = session.run("MATCH (s:State {key:'initialValue'}) RETURN s").single().get("s").asNode();

        // When
        StatementResult result = session.run("MATCH (e:Entity) WITH e CALL graph.versioner.get.all(e) YIELD path RETURN path");

        Path current = result.single().get("path").asPath();
        Iterator<Relationship> relsIterator = current.relationships().iterator();
        Map<String, Object> rels = new HashMap<>();
        while (relsIterator.hasNext()) {
            Relationship support = relsIterator.next();
            rels.put(support.type(), support);
        }

        // Then
        assertThat(current.contains(entity), equalTo(true));
        assertThat(current.contains(stateNew), equalTo(true));
    }
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
Neo4JEdge(Neo4JGraph graph, Neo4JSession session, Neo4JElementIdProvider<?> edgeIdProvider, Neo4JVertex out, Relationship relationship, Neo4JVertex in) {
    Objects.requireNonNull(graph, "graph cannot be null");
    Objects.requireNonNull(session, "session cannot be null");
    Objects.requireNonNull(edgeIdProvider, "edgeIdProvider cannot be null");
    Objects.requireNonNull(out, "out cannot be null");
    Objects.requireNonNull(relationship, "relationship cannot be null");
    Objects.requireNonNull(in, "in cannot be null");
    // store fields
    this.graph = graph;
    this.session = session;
    this.edgeIdProvider = edgeIdProvider;
    // from relationship
    this.id = edgeIdProvider.get(relationship);
    this.label = relationship.type();
    // id field name (if any)
    String idFieldName = edgeIdProvider.fieldName();
    // copy properties from relationship, remove idFieldName from map
    StreamSupport.stream(relationship.keys().spliterator(), false).filter(key -> !key.equals(idFieldName)).forEach(key -> {
        // value
        Value value = relationship.get(key);
        // add property value
        properties.put(key, new Neo4JEdgeProperty<>(this, key, value.asObject()));
    });
    // vertices
    this.out = out;
    this.in = in;
    // initialize original properties
    originalProperties = new HashMap<>(properties);
    // this is a persisted edge
    newEdge = false;
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Test
public void prettyPrintRelationships() throws Exception {
    // given
    BoltResult result = mock(BoltResult.class);

    Record record = mock(Record.class);
    Value value = mock(Value.class);

    Relationship relationship = mock(Relationship.class);
    HashMap<String, Object> propertiesAsMap = new HashMap<>();
    propertiesAsMap.put("prop1", "prop1_value");
    propertiesAsMap.put("prop2", "prop2_value");

    when(value.type()).thenReturn(InternalTypeSystem.TYPE_SYSTEM.RELATIONSHIP());

    when(value.asRelationship()).thenReturn(relationship);
    when(relationship.type()).thenReturn("RELATIONSHIP_TYPE");
    when(relationship.asMap(anyObject())).thenReturn(unmodifiableMap(propertiesAsMap));

    when(record.keys()).thenReturn(asList("rel"));
    when(record.get(eq("rel"))).thenReturn(value);
    when(record.values()).thenReturn(asList(value));
    when(record.asMap(anyObject())).thenReturn(Collections.singletonMap("rel",value));
    when(result.getRecords()).thenReturn(asList(record));
    when(result.getSummary()).thenReturn(mock(ResultSummary.class));

    // when
    String actual = verbosePrinter.format(result);

    // then
    assertThat(actual, containsString("| [:RELATIONSHIP_TYPE {prop2: prop2_value, prop1: prop1_value}] |"));
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Test
public void prettyPrintRelationships() throws Exception {
    // given
    BoltResult result = mock(BoltResult.class);

    Record record = mock(Record.class);
    Value value = mock(Value.class);

    Relationship relationship = mock(Relationship.class);
    HashMap<String, Object> propertiesAsMap = new HashMap<>();
    propertiesAsMap.put("prop1", "prop1_value");
    propertiesAsMap.put("prop2", "prop2_value");

    when(value.type()).thenReturn(InternalTypeSystem.TYPE_SYSTEM.RELATIONSHIP());

    when(value.asRelationship()).thenReturn(relationship);
    when(relationship.type()).thenReturn("RELATIONSHIP_TYPE");
    when(relationship.asMap(anyObject())).thenReturn(unmodifiableMap(propertiesAsMap));

    when(record.keys()).thenReturn(asList("rel"));
    when(record.values()).thenReturn(asList(value));

    when(result.getRecords()).thenReturn(asList(record));
    when(result.getSummary()).thenReturn(mock(ResultSummary.class));

    // when
    String actual = plainPrinter.format(result);

    // then
    assertThat(actual, is("rel\n[:RELATIONSHIP_TYPE {prop2: prop2_value, prop1: prop1_value}]"));
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
private InterpreterResult renderGraph(Set<Node> nodes,
    Set<Relationship> relationships) {
  logger.info("Executing renderGraph method");
  List<org.apache.zeppelin.tabledata.Node> nodesList = new ArrayList<>();
  List<org.apache.zeppelin.tabledata.Relationship> relsList = new ArrayList<>();
  for (Relationship rel : relationships) {
    relsList.add(Neo4jConversionUtils.toZeppelinRelationship(rel));
  }
  Map<String, String> labels = getLabels(true);
  for (Node node : nodes) {
    nodesList.add(Neo4jConversionUtils.toZeppelinNode(node, labels));
  }
  return new GraphResult(Code.SUCCESS,
      new GraphResult.Graph(nodesList, relsList, labels, getTypes(true), true));
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Override
public String getRelationType(long relationId, int rowIndex) {
	if (rowIndex >= 0) {
		Relationship rel = (Relationship) getPropertiesObject(relationId, rowIndex, ElemType.RELATION);
		return rel.type();
	}
	return null;
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Override
public Object convert(Object value) {
    if (value instanceof Node) {
        return sessionCache.getNode((Node) value);
    } else if (value instanceof Relationship) {
        return sessionCache.getRelationship((Relationship) value);
    }
    throw new XOException("Unsupported value type " + value);
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
@Override
public RemoteRelationship findRelationById(RelationTypeMetadata<RelationshipMetadata<RemoteRelationshipType>> metadata, Long id) {
    String statement = String.format("MATCH (start)-[r:%s]->(end) WHERE id(r)={id} RETURN start,r,end",
            metadata.getDatastoreMetadata().getDiscriminator().getName());
    Record record = statementExecutor.getSingleResult(statement, parameters("id", id));
    Node start = record.get("start").asNode();
    Relationship relationship = record.get("r").asRelationship();
    Node end = record.get("end").asNode();
    return datastoreSessionCache.getRelationship(start, relationship, end);
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
private StateTracker<RemoteRelationship, Set<RemoteRelationship>> getRelationships(RemoteNode source, RemoteRelationshipType type,
        RemoteDirection remoteDirection) {
    StateTracker<RemoteRelationship, Set<RemoteRelationship>> trackedRelationships = source.getState().getRelationships(remoteDirection, type);
    if (trackedRelationships == null) {
        String sourceIdentifier;
        switch (remoteDirection) {
        case OUTGOING:
            sourceIdentifier = "start";
            break;
        case INCOMING:
            sourceIdentifier = "end";
            break;
        default:
            throw new XOException("Direction not supported: " + remoteDirection);
        }
        String statement = String.format("MATCH (start)-[r:%s]->(end) WHERE id(%s)={id} RETURN start,r,end", type.getName(), sourceIdentifier);
        StatementResult statementResult = statementExecutor.execute(statement, parameters("id", source.getId()));
        Set<RemoteRelationship> loaded = new LinkedHashSet<>();
        try {
            while (statementResult.hasNext()) {
                Record record = statementResult.next();
                Node start = record.get("start").asNode();
                Relationship relationship = record.get("r").asRelationship();
                Node end = record.get("end").asNode();
                RemoteRelationship remoteRelationship = datastoreSessionCache.getRelationship(start, relationship, end);
                loaded.add(remoteRelationship);
            }
        } finally {
            statementResult.consume();
        }
        trackedRelationships = new StateTracker<>(loaded);
        source.getState().setRelationships(remoteDirection, type, trackedRelationships);
    }
    return trackedRelationships;
}
 

import org.neo4j.driver.v1.types.Relationship; //导入依赖的package包/类
private RemoteRelationship getRelationship(Relationship relationship, RemoteNode startNode, RemoteNode endNode, RemoteRelationshipType type) {
    RemoteRelationship remoteRelationship = getRelationship(relationship.id(), startNode, type, endNode);
    if (!remoteRelationship.getState().isLoaded()) {
        remoteRelationship.getState().load(relationship.asMap());
    }
    return remoteRelationship;
}