import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Test
public void generates_executable_dump() throws IOException {
    exporter.accept(dump, asList(
            exercise("foo", "MATCH (n:Foo) RETURN COUNT(n) AS foo_count"),
            exercise("bar", "MATCH (n:Bar) RETURN COUNT(n) AS bar_count"),
            exercise("baz", "MATCH (n:Baz) RETURN COUNT(n) AS baz_count", "CREATE (:Baz {name:'meh'})")));

    lines(dump.toPath(), UTF_8).forEachOrdered(line -> {
        try (Driver driver = GraphDatabase.driver(graphDb.boltURI(), config()); Session session = driver.session()) {
            session.run(line);
        }
    });

    try (Driver driver = GraphDatabase.driver(graphDb.boltURI(), config()); Session session = driver.session()) {
        StatementResult result = session.run(
                "MATCH p=(e1:Exercise)-[:NEXT*]->(e2:Exercise) WITH p ORDER BY LENGTH(p) DESC LIMIT 1 " +
                        "RETURN EXTRACT(exercise IN NODES(p) | exercise.instructions) AS instructions");
        assertThat(result.single().get("instructions").asList(Value::asString)).containsExactly("foo", "bar", "baz");
        result = session.run(
                "MATCH (e:Exercise) WHERE EXISTS(e.validationQuery) RETURN e.instructions AS instruction");
        assertThat(result.single().get("instruction").asString()).isEqualTo("baz");
    }
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
private void process(ProfiledPlan profilePlan, int indentationLevel) {
    // create details instance
    ProfileInformationDetails information = new ProfileInformationDetails();
    // operator
    information.operator = printOperator(profilePlan.operatorType(), indentationLevel);
    // arguments
    Map<String, Value> arguments = profilePlan.arguments();
    // compile information
    information.indentationLevel = indentationLevel;
    information.estimatedRows = printEstimatedRows(arguments.get("EstimatedRows"));
    information.rows = String.format(Locale.US, "%d", profilePlan.records());
    information.dbHits = String.format(Locale.US, "%d", profilePlan.dbHits());
    information.variables = profilePlan.identifiers().stream().map(String::trim).collect(Collectors.joining(", "));
    information.otherInformation = printOtherInformation(arguments);
    // append to list
    add(information);
    // children
    List<ProfiledPlan> children = profilePlan.children();
    // process children (backwards)
    for (int i = children.size() - 1; i >= 0; i--) {
        // current child
        ProfiledPlan child = children.get(i);
        // process child
        process(child, indentationLevel + i);
    }
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Nonnull
String formatValues(@Nonnull List<Value> data) {
    if (data.isEmpty()) return "";
    List<String> columns = Iterables.asList(data.get(0).keys());
    if (columns.isEmpty()) return "";

    StringBuilder sb = new StringBuilder();
    Map<String, Integer> columnSizes = calculateColumnSizes(columns, data);
    String headerLine = createString(columns, columnSizes);
    int lineWidth = headerLine.length() - 2;
    String dashes = "+" + OutputFormatter.repeat('-', lineWidth) + "+";

    sb.append(dashes).append(NEWLINE);
    sb.append(headerLine).append(NEWLINE);
    sb.append(dashes).append(NEWLINE);

    for (Value record : data) {
        sb.append(createString(columns, columnSizes, record)).append(NEWLINE);
    }
    sb.append(dashes).append(NEWLINE);
    return sb.toString();
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Nonnull default String formatValue(@Nonnull final Value value) {
    TypeRepresentation type = (TypeRepresentation) value.type();
    switch (type.constructor()) {
        case LIST_TyCon:
            return listAsString(value.asList(this::formatValue));
        case MAP_TyCon:
            return mapAsString(value.asMap(this::formatValue));
        case NODE_TyCon:
            return nodeAsString(value.asNode());
        case RELATIONSHIP_TyCon:
            return relationshipAsString(value.asRelationship());
        case PATH_TyCon:
            return pathAsString(value.asPath());
        case ANY_TyCon:
        case BOOLEAN_TyCon:
        case STRING_TyCon:
        case NUMBER_TyCon:
        case INTEGER_TyCon:
        case FLOAT_TyCon:
        case NULL_TyCon:
        default:
            return value.toString();
    }
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Test
public void shouldRunCypherQuery() throws CommandException {
    Session sessionMock = mock(Session.class);
    StatementResult versionMock = mock(StatementResult.class);
    StatementResult resultMock = mock(StatementResult.class);
    Record recordMock = mock(Record.class);
    Value valueMock = mock(Value.class);

    Driver driverMock = stubVersionInAnOpenSession(versionMock, sessionMock, "neo4j-version");

    when(resultMock.list()).thenReturn(asList(recordMock));

    when(valueMock.toString()).thenReturn("999");
    when(recordMock.get(0)).thenReturn(valueMock);
    when(sessionMock.run(any(Statement.class))).thenReturn(resultMock);

    OfflineBoltStateHandler boltStateHandler = new OfflineBoltStateHandler(driverMock);

    boltStateHandler.connect();

    BoltResult boltResult = boltStateHandler.runCypher("RETURN 999",
            new HashMap<>()).get();
    verify(sessionMock).run(any(Statement.class));

    assertEquals("999", boltResult.getRecords().get(0).get(0).toString());
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Test
public void setParamShouldAddParamWithSpecialCharactersAndValue() throws CommandException {
    Value value = mock(Value.class);
    Record recordMock = mock(Record.class);
    BoltResult boltResult = mock(BoltResult.class);

    when(mockedBoltStateHandler.runCypher(anyString(), anyMap())).thenReturn(Optional.of(boltResult));
    when(boltResult.getRecords()).thenReturn(asList(recordMock));
    when(recordMock.get("bo`b")).thenReturn(value);
    when(value.asObject()).thenReturn("99");

    assertTrue(offlineTestShell.getAll().isEmpty());

    Optional result = offlineTestShell.set("`bo``b`", "99");
    assertEquals("99", result.get());
    assertEquals("99", offlineTestShell.getAll().get("bo`b"));
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Test
public void setParamShouldAddParam() throws CommandException {
    Value value = mock(Value.class);
    Record recordMock = mock(Record.class);
    BoltResult boltResult = mock(BoltResult.class);

    when(mockedBoltStateHandler.runCypher(anyString(), anyMap())).thenReturn(Optional.of(boltResult));
    when(boltResult.getRecords()).thenReturn(asList(recordMock));
    when(recordMock.get("bob")).thenReturn(value);
    when(value.asObject()).thenReturn("99");

    assertTrue(offlineTestShell.getAll().isEmpty());

    Optional result = offlineTestShell.set("`bob`", "99");
    assertEquals("99", result.get());
    assertEquals("99", offlineTestShell.getAll().get("bob"));
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Override
public void executeOperation(LdbcUpdate2AddPostLike operation,
    DbConnectionState dbConnectionState,
    ResultReporter reporter) throws DbException {

  Driver driver = ((Neo4jDbConnectionState) dbConnectionState).getDriver();

  try (Session session = driver.session(AccessMode.WRITE)) {
    try (Transaction tx = session.beginTransaction()) {
      String statement =
          "   MATCH (p:Person {id:{personId}}),"
          + "       (m:Post {id:{postId}})"
          + " CREATE (p)-[:LIKES {creationDate:{creationDate}}]->(m)";
      Value parameters = parameters(
          "personId", String.valueOf(operation.personId()),
          "postId", String.valueOf(operation.postId()),
          "creationDate", operation.creationDate().getTime());

      tx.run(statement, parameters);
      tx.success();
      tx.close();
    }
  }

  reporter.report(0, LdbcNoResult.INSTANCE, operation);
}
 

import org.neo4j.driver.v1.Value; //导入依赖的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.Value; //导入依赖的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.Value; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <T> void addValue(String colKey, List<T> vals) {
	Value val;
	try {
		val = this.record.get(colKey);
	} catch (NoSuchRecordException e) {
		throw new RuntimeException("no result column: " + colKey);
	}
	Object v = convertContentValue(val);
	if (v != null)
		vals.add((T) v);
	else {
		if (ResultHandler.includeNullValues.get().booleanValue() 
				|| ResultSettings.includeNullValuesAndDuplicates.get().booleanValue())
			vals.add((T) v);
	}
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
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;
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Override
public void close() {
    for (Map.Entry<String, BatchEntry> entry : batches.entrySet()) {
        String statement = entry.getKey();
        BatchEntry batchEntry = entry.getValue();
        List<Value> batch = batchEntry.getBatch();
        if (!batch.isEmpty()) {
            String batchStatement = "UNWIND {batch} as entry " + statement;
            Record result = statementExecutor.getSingleResult(batchStatement, parameters("batch", batch));
            Callback callback = batchEntry.getCallback();
            if (callback != null) {
                callback.process(result);
            }
        }
    }
    batches.clear();
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
private void createNode( String username, PrivateKey privateKey )
{
    AuthToken authToken = pkiAuthToken( username, privateKey );

    try ( Driver driver = GraphDatabase.driver( server.boltURI(), authToken );
            Session session = driver.session() )
    {
        String nodeName = UUID.randomUUID().toString();
        session.run( "CREATE ({name: '" + nodeName + "'})" ).consume();
        Value value = session.run( "MATCH (n {name: '" + nodeName + "'}) RETURN count(n)" ).single().get( 0 );
        assertThat( value.asLong(), equalTo( 1L ) );
    }
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
private void readNodes( String username, PrivateKey privateKey )
{
    AuthToken authToken = pkiAuthToken( username, privateKey );

    try ( Driver driver = GraphDatabase.driver( server.boltURI(), authToken );
            Session session = driver.session() )
    {
        Value value = session.run( "MATCH (n) RETURN count(n)" ).single().get( 0 );
        assertThat( value.asLong(), greaterThanOrEqualTo( 1L ) );
    }
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Test
public void shouldAuthenticateNeo4jUser() throws Throwable
{
    // When & Then
    try( Driver driver = GraphDatabase.driver( server.boltURI(),
         AuthTokens.basic( "neo4j", "neo4j" ) );
         Session session = driver.session() )
    {
        Value single = session.run( "RETURN 1" ).single().get( 0 );
        assertThat( single.asLong(), equalTo( 1L ) );
    }
}
 

import org.neo4j.driver.v1.Value; //导入依赖的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.Value; //导入依赖的package包/类
@Override
public Neo4JDatabaseCommand updateCommand() {
    // check edge is dirty
    if (dirty) {
        // update statement
        String statement = out.matchStatement("o", "oid") + " " + in.matchStatement("i", "iid") + " MATCH (o)-[r:`" + label + "`]->(i)" + " WHERE " + edgeIdProvider.matchPredicateOperand("r") + " = {id} SET r = {rp}";
        // parameters
        Value parameters = Values.parameters("oid", out.id(), "iid", in.id(), "id", id(), "rp", statementParameters());
        // command statement
        return new Neo4JDatabaseCommand(new Statement(statement, parameters), result -> {
        });
    }
    return null;
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Override
public Neo4JDatabaseCommand deleteCommand() {
    // delete statement
    String statement = out.matchStatement("o", "oid") + " " + in.matchStatement("i", "iid") + " MATCH (o)-[r:`" + label + "`]->(i)" + " WHERE " + edgeIdProvider.matchPredicateOperand("r") + " = {id} DELETE r";
    // parameters
    Value parameters = Values.parameters("oid", out.id(), "iid", in.id(), "id", id());
    // command statement
    return new Neo4JDatabaseCommand(new Statement(statement, parameters), result -> {
    });
}
 

import org.neo4j.driver.v1.Value; //导入依赖的package包/类
@Override
public Neo4JDatabaseCommand insertCommand() {
    // concat labels with additional labels on insertion
    SortedSet<String> labels = Stream.concat(this.labels.stream(), additionalLabels.stream()).collect(Collectors.toCollection(TreeSet::new));
    try {
        // parameters
        Value parameters = Values.parameters("vp", statementParameters());
        // check database side id generation is required
        if (id == null) {
            // create statement
            String statement = "CREATE (n" + processLabels(labels, false) + "{vp}) RETURN " + vertexIdProvider.matchPredicateOperand("n");
            // command statement
            return new Neo4JDatabaseCommand(new Statement(statement, parameters), result -> {
                // check we received data
                if (result.hasNext()) {
                    // record
                    Record record = result.next();
                    // process node identifier
                    generatedId = vertexIdProvider.processIdentifier(record.get(0).asObject());
                }
            });
        }
        // command statement
        return new Neo4JDatabaseCommand(new Statement("CREATE (" + processLabels(labels, false) + "{vp})", parameters));
    }
    finally {
        // to find vertex in database (labels + additional labels)
        matchLabels = labels;
    }
}