private Stream<RowResult> getRowResultStream(boolean virtual, Session session, Map<String, Object> params, String statement, boolean read) { Map<Long, Object> nodesCache = new HashMap<>(); return StreamSupport.stream(Spliterators.spliteratorUnknownSize(runStatement(statement, session, params, read), 0), true) .map(record -> new RowResult(record.asMap(value -> { Object entity = value.asObject(); if (entity instanceof Node) return toNode(entity, virtual, nodesCache); if (entity instanceof Relationship) return toRelationship(entity, virtual, nodesCache); if (entity instanceof Path) return toPath(entity, virtual, nodesCache); return entity; }))); }
@Test public void shouldStart() { boolean actual = neo4jContainer.isRunning(); assertThat(actual).isTrue(); try (Driver driver = GraphDatabase .driver(neo4jContainer.getBoltUrl(), AuthTokens.basic("neo4j", "password")); Session session = driver.session() ) { long one = session.run("RETURN 1", Collections.emptyMap()).next().get(0).asLong(); assertThat(one).isEqualTo(1L); } catch (Exception e) { fail(e.getMessage()); } }
@Test public void shouldRunEnterprise() { assumeThat(Neo4jContainerTest.class.getResource(ACCEPTANCE_FILE_LOCATION)).isNotNull(); try ( Neo4jContainer neo4jContainer = new Neo4jContainer() .withEnterpriseEdition() .withAdminPassword("Picard123") ) { neo4jContainer.start(); try ( Driver driver = getDriver(neo4jContainer); Session session = driver.session() ) { String edition = session .run("CALL dbms.components() YIELD edition RETURN edition", Collections.emptyMap()) .next().get(0).asString(); assertThat(edition).isEqualTo("enterprise"); } } }
private Object toNode(Object value, boolean virtual, Map<Long, Object> nodesCache) { Value internalValue = ((InternalEntity) value).asValue(); Node node = internalValue.asNode(); if (virtual) { List<Label> labels = new ArrayList<>(); node.labels().forEach(l -> labels.add(Label.label(l))); VirtualNode virtualNode = new VirtualNode(node.id(), labels.toArray(new Label[0]), node.asMap(), db); nodesCache.put(node.id(), virtualNode); return virtualNode; } else return Util.map("entityType", internalValue.type().name(), "labels", node.labels(), "id", node.id(), "properties", node.asMap()); }
private Object toRelationship(Object value, boolean virtual, Map<Long, Object> nodesCache) { Value internalValue = ((InternalEntity) value).asValue(); Relationship relationship = internalValue.asRelationship(); if (virtual) { VirtualNode start = (VirtualNode) nodesCache.getOrDefault(relationship.startNodeId(), new VirtualNode(relationship.startNodeId(), db)); VirtualNode end = (VirtualNode) nodesCache.getOrDefault(relationship.endNodeId(), new VirtualNode(relationship.endNodeId(), db)); VirtualRelationship virtualRelationship = new VirtualRelationship(relationship.id(), start, end, RelationshipType.withName(relationship.type()), relationship.asMap()); return virtualRelationship; } else return Util.map("entityType", internalValue.type().name(), "type", relationship.type(), "id", relationship.id(), "start", relationship.startNodeId(), "end", relationship.endNodeId(), "properties", relationship.asMap()); }
@Nonnull default String formatValue(@Nonnull final Value value) { TypeRepresentation type = (TypeRepresentation) value.type(); switch (type.constructor()) { case LIST: return listAsString(value.asList(this::formatValue)); case MAP: return mapAsString(value.asMap(this::formatValue)); case NODE: return nodeAsString(value.asNode()); case RELATIONSHIP: return relationshipAsString(value.asRelationship()); case PATH: return pathAsString(value.asPath()); case POINT: return pointAsString(value.asPoint()); case ANY: case BOOLEAN: case NULL: default: return value.toString();
@Test public void returnNodeAndRelationship() { Driver driver = GremlinDatabase.driver("//localhost:" + server.getPort()); try (Session session = driver.session()) { StatementResult result = session.run("CREATE (n1:Person {name: 'Marko'})-[r:knows {since:1999}]->(n2:Person)" + "RETURN n1,r,n2", parameters("message", "Hello")); Record record = result.single(); Node n1 = record.get("n1").asNode(); Relationship r = record.get("r").asRelationship(); Node n2 = record.get("n2").asNode(); assertThat(n1.hasLabel("Person")).isTrue(); assertThat(n1.get("name").asString()).isEqualTo("Marko"); assertThat(r.hasType("knows")).isTrue(); assertThat(r.startNodeId()).isEqualTo(n1.id()); assertThat(r.endNodeId()).isEqualTo(n2.id()); assertThat(r.get("since").asLong()).isEqualTo(1999L); assertThat(n2.hasLabel("Person")).isTrue(); } }
public static ElementInfo fromRecordValue(Value val) { if (val instanceof ListValue) return ElementInfo.fromRecordValue(((ListValue)val).get(0)); ElementInfo ret = null; if (val != null) { String typName = val.type().name(); // NODE, RELATIONSHIP, NULL if ("NODE".equals(typName)) { ret = new ElementInfo(); ret.isNull = false; ret.id = val.asNode().id(); ret.type = ElemType.NODE; } else if ("RELATIONSHIP".equals(typName)) { ret = new ElementInfo(); ret.isNull = false; ret.id = val.asRelationship().id(); ret.type = ElemType.RELATION; } else if ("NULL".equals(typName)) ret = ElementInfo.nullElement(); } return ret; }
@Override public T apply( Value plan ) { final String operatorType = plan.get( "operatorType" ).asString(); final Value argumentsValue = plan.get( "args" ); final Map<String, Value> arguments = argumentsValue.isNull() ? Collections.<String, Value>emptyMap() : argumentsValue.asMap( Values.ofValue() ); final Value identifiersValue = plan.get( "identifiers" ); final List<String> identifiers = identifiersValue.isNull() ? Collections.<String>emptyList() : identifiersValue.asList( ofString() ); final Value childrenValue = plan.get( "children" ); final List<T> children = childrenValue.isNull() ? Collections.<T>emptyList() : childrenValue.asList( this ); return planCreator.create( operatorType, arguments, identifiers, children, plan ); } }
@Test public void shouldCreateAnRNodeConnectedToTheEntity() throws Throwable { try (Driver driver = GraphDatabase.driver(neo4j.boltURI(), Config.build().withEncryption().toConfig()); Session session = driver.session()) { StatementResult result = session.run("CALL graph.versioner.init('Entity')"); StatementResult rPath = session.run("MATCH rPath = (:R)-[:FOR]->(:Entity) RETURN rPath"); Assertions.assertThat(result.single().get("node").asNode().id()).isEqualTo(0L); Assertions.assertThat(rPath) .hasSize(1) .allMatch(path -> path.get("rPath").asPath().length() == 1); } } }
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); }
@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; }
@Test public void shouldCreateAnEntityWithPropertiesWithAState() throws Throwable { // 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()) { // When StatementResult result = session.run("CALL graph.versioner.init('Entity', {key:'value'})"); StatementResult entityResult = session.run("MATCH (e:Entity) RETURN properties(e) as props"); StatementResult stateResult = session.run("MATCH (s:State) RETURN s"); StatementResult currentResult = session.run("MATCH (e:Entity)-[:CURRENT]->(s:State) RETURN id(e) as id"); Node state = stateResult.single().get("s").asNode(); // Then assertThat(result.single().get("node").asNode().id(), equalTo(0L)); assertThat(entityResult.single().get("props").asMap().isEmpty(), equalTo(false)); assertThat(state.id(), equalTo(1L)); assertThat(currentResult.single().get("id").asLong(), equalTo(0L)); } }
@Test public void returnPath() { Driver driver = GremlinDatabase.driver("//localhost:" + server.getPort()); try (Session session = driver.session()) { StatementResult setup = session.run("CREATE (n1:Person {name: 'Anders'})-[r:knows]->(n2:Person)" + "RETURN n1,r,n2"); Record createdNodes = setup.single(); Node n1 = createdNodes.get("n1").asNode(); Node n2 = createdNodes.get("n2").asNode(); Relationship r = createdNodes.get("r").asRelationship(); StatementResult result = session.run("MATCH p =(b1 { name: 'Anders' })-->()" + "RETURN p"); Path path = result.single().get("p").asPath(); assertThat(path.contains(n1)).isTrue(); assertThat(path.contains(n2)).isTrue(); assertThat(path.contains(r)).isTrue(); assertThat(path.relationships()).hasSize(1); assertThat(path.nodes()).hasSize(2); } }
public static final String formatToString(Value value) { if(value instanceof StringValue) return value.asString(); else if(value instanceof IntegerValue) return String.valueOf(value.asInt()); else if(value instanceof FloatValue) return String.valueOf(value.asFloat()); else if(value instanceof BooleanValue) return String.valueOf(value.asBoolean()); throw new NotSupportConvertException(); }
@Test public void originalIds() throws ExecutionException, InterruptedException { String uri = "//localhost:" + gremlinServer.getPort(); String uuid = "ef8b80c9-f8f9-40b6-bad2-ee4757d5bb33"; gremlinServer.gremlinClient().submit(format("g.addV('VertexWithStringId').property(id, '%s')", uuid)).all().get(); // freshReadmeSnippet: originalIds Config config = Config.build() .withTranslation(TranslatorFlavor.gremlinServer()) .ignoreIds() .toConfig(); Driver driver = GremlinDatabase.driver(uri, config); try (Session session = driver.session()) { StatementResult getOriginal = session.run("MATCH (n:VertexWithStringId) RETURN id(n) as id"); Object originalId = getOriginal.single().get("id").asObject(); assertThat(originalId).isEqualTo(uuid); // ef8b80c9-f8f9-40b6-bad2-ee4757d5bb33 StatementResult result = session.run("MATCH (n) WHERE id(n) = $originalId RETURN n", singletonMap("originalId", originalId)); Node n = result.single().get("n").asNode(); assertThat(n.id()).isEqualTo(-1); // -1 } // freshReadmeSnippet: originalIds } }
private void addTargetEmbeddedProperties(Map<String, Object> targetNode, Record row) { if ( !row.get( 1 ).isNull() ) { List<Object> pathToNode = row.get( 1 ).asList(); Map<String, Object> embeddedNodeProperties = (Map<String, Object>) row.get( 3 ).asMap(); String path = concat( pathToNode ); for ( Map.Entry<String, Object> entry : embeddedNodeProperties.entrySet() ) { targetNode.put( path + "." + entry.getKey(), entry.getValue() ); } } }