Java Driver类代码示例

import org.neo4j.driver.v1.Driver; //导入依赖的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.Driver; //导入依赖的package包/类
private PrivateKey addNewUser( PrivateKey defaultUserPrivateKey, String username, String... roles )
{
    KeyPair newUserKeyPair = generateKeyPair();

    AuthToken authToken = pkiAuthToken( DEFAULT_USER, defaultUserPrivateKey );
    try ( Driver driver = GraphDatabase.driver( server.boltURI(), authToken );
            Session session = driver.session() )
    {
        String query = "CALL addPkiUser({username}, {key}, {roles})";

        Map<String,Object> params = new HashMap<>();
        params.put( "username", username );
        params.put( "key", publicKeyAsString( newUserKeyPair.getPublic() ) );
        params.put( "roles", roles );

        session.run( query, params ).consume();
    }

    return newUserKeyPair.getPrivate();
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
@Test
public void shouldAuthenticateAndAuthorizeKalleMoraeusAsAdmin() throws Exception
{
    Driver driver = GraphDatabase.driver( server.boltURI(), AuthTokens.basic( "moraeus", "suearom" ) );
    Session session = driver.session();

    session.run( "CREATE (a:Person {name:'Kalle Moraeus', title:'Riksspelman'})" );

    StatementResult result =
            session.run( "MATCH (a:Person) WHERE a.name = 'Kalle Moraeus' RETURN a.name AS name, a.title AS title" );
    assertTrue( result.hasNext() );
    while ( result.hasNext() )
    {
        Record record = result.next();
        assertThat( record.get( "name" ).asString(), equalTo( "Kalle Moraeus" ) );
        assertThat( record.get( "title" ).asString(), equalTo( "Riksspelman" ) );
        System.out.println( record.get( "title" ).asString() + " " + record.get( "name" ).asString() );
    }

    session.close();
    driver.close();
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
@Test
public void shouldRunHelloWorldExample() throws Throwable
{
    System.in.read();
    // Given
    try( Driver driver = GraphDatabase.driver( "bolt://localhost" ) )
    {
        Session session = driver.session();

        // Register a cypher query as a GraphQL field
        session.run( "CALL graphql.createQueryField('hello', 'RETURN \"hello, world!\"')" );

        // And then run a graphQL query against the updated schema
        System.out.println(
                session.run( "CALL graphql.query('{hello}')" )
                .single()
                .get(0).asMap());

    }
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
@Test
public void calls_procedures_with_simple_input_type_returning_void()
{
    try ( Driver driver = GraphDatabase.driver( graphDb.boltURI(), configuration() );
            Session session = driver.session() )
    {

        session.run( "CALL " + procedureNamespace + ".simpleInput00()" );
        session.run( "CALL " + procedureNamespace + ".simpleInput01('string')" );
        session.run( "CALL " + procedureNamespace + ".simpleInput02(42)" );
        session.run( "CALL " + procedureNamespace + ".simpleInput03(42)" );
        session.run( "CALL " + procedureNamespace + ".simpleInput04(4.2)" );
        session.run( "CALL " + procedureNamespace + ".simpleInput05(true)" );
        session.run( "CALL " + procedureNamespace + ".simpleInput06(false)" );
        session.run( "CALL " + procedureNamespace + ".simpleInput07({foo:'bar'})" );
        session.run( "MATCH (n)            CALL " + procedureNamespace + ".simpleInput08(n) RETURN n" );
        session.run( "MATCH p=(()-[r]->()) CALL " + procedureNamespace + ".simpleInput09(p) RETURN p" );
        session.run( "MATCH ()-[r]->()     CALL " + procedureNamespace + ".simpleInput10(r) RETURN r" );
    }
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
@Test
public void calls_procedures_with_simple_input_type_returning_record_with_primitive_fields()
{
    try ( Driver driver = GraphDatabase.driver( graphDb.boltURI(), configuration() );
            Session session = driver.session() )
    {

        assertThat( session.run( "CALL " + procedureNamespace + ".simpleInput11('string')" ).single() ).isNotNull();
        assertThat( session.run( "CALL " + procedureNamespace + ".simpleInput12(42)" ).single() ).isNotNull();
        assertThat( session.run( "CALL " + procedureNamespace + ".simpleInput13(42)" ).single() ).isNotNull();
        assertThat( session.run( "CALL " + procedureNamespace + ".simpleInput14(4.2)" ).single() ).isNotNull();
        assertThat( session.run( "CALL " + procedureNamespace + ".simpleInput15(true)" ).single() ).isNotNull();
        assertThat( session.run( "CALL " + procedureNamespace + ".simpleInput16(false)" ).single() ).isNotNull();
        assertThat( session.run( "CALL " + procedureNamespace + ".simpleInput17({foo:'bar'})" ).single() )
                .isNotNull();
        assertThat( session.run( "CALL " + procedureNamespace + ".simpleInput21()" ).single() ).isNotNull();
    }

}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
/**
 * Creates a {@link Neo4JGraph} instance.
 *
 * @param driver           The {@link Driver} instance with the database connection information.
 * @param vertexIdProvider The {@link Neo4JElementIdProvider} for the {@link Vertex} id generation.
 * @param edgeIdProvider   The {@link Neo4JElementIdProvider} for the {@link Edge} id generation.
 */
public Neo4JGraph(Driver driver, Neo4JElementIdProvider<?> vertexIdProvider, Neo4JElementIdProvider<?> edgeIdProvider) {
    Objects.requireNonNull(driver, "driver cannot be null");
    Objects.requireNonNull(vertexIdProvider, "vertexIdProvider cannot be null");
    Objects.requireNonNull(edgeIdProvider, "edgeIdProvider cannot be null");
    // no label partition
    this.partition = new NoReadPartition();
    this.vertexLabels = Collections.emptySet();
    // store driver instance
    this.driver = driver;
    // store providers
    this.vertexIdProvider = vertexIdProvider;
    this.edgeIdProvider = edgeIdProvider;
    // graph factory configuration (required for tinkerpop test suite)
    this.configuration = null;
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
static Neo4JElementIdProvider<?> loadProvider(Driver driver, String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    // check class name
    if (className != null) {
        // load class
        Class<?> type = Class.forName(className);
        try {
            // check class has constructor with a Driver parameter
            Constructor<?> constructor = type.getConstructor(Driver.class);
            // create instance
            return (Neo4JElementIdProvider<?>)constructor.newInstance(driver);
        }
        catch (NoSuchMethodException | InvocationTargetException ex) {
            // create instance
            return (Neo4JElementIdProvider<?>)type.newInstance();
        }
    }
    return null;
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
@Override
public void clear(Graph graph, Configuration configuration) throws Exception {
    // check graph instance
    if (graph != null) {
        // close graph instance
        graph.close();
    }
    // connect to server
    try (Driver driver = GraphDatabase.driver(configuration.getString(Neo4JGraphConfigurationBuilder.Neo4JUrlConfigurationKey), AuthTokens.basic(configuration.getString(Neo4JGraphConfigurationBuilder.Neo4JUsernameConfigurationKey), configuration.getString(Neo4JGraphConfigurationBuilder.Neo4JPasswordConfigurationKey)), Config.defaultConfig())) {
        // open session
        try (Session session = driver.session()) {
            // begin transaction
            try (org.neo4j.driver.v1.Transaction transaction = session.beginTransaction()) {
                // delete everything in database
                transaction.run(new Statement("MATCH (n) DETACH DELETE n"));
                // commit
                transaction.success();
            }
        }
    }
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
@Test
public void exceptionsFromSilentDisconnectAreSuppressedToReportOriginalErrors() throws CommandException {
    Session session = mock(Session.class);
    StatementResult resultMock = mock(StatementResult.class);

    RuntimeException originalException = new RuntimeException("original exception");
    RuntimeException thrownFromSilentDisconnect = new RuntimeException("exception from silent disconnect");


    Driver mockedDriver = stubVersionInAnOpenSession(resultMock, session, "neo4j-version");
    OfflineBoltStateHandler boltStateHandler = new OfflineBoltStateHandler(mockedDriver);

    when(resultMock.consume()).thenThrow(originalException);
    doThrow(thrownFromSilentDisconnect).when(session).close();

    try {
        boltStateHandler.connect();
        fail("should fail on silent disconnect");
    } catch (Exception e) {
        assertThat(e.getSuppressed()[0], is(thrownFromSilentDisconnect));
        assertThat(e, is(originalException));
    }
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的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.Driver; //导入依赖的package包/类
@Test
public void resetSessionOnReset() throws Exception {
    // given
    Session sessionMock = mock(Session.class);
    Driver driverMock = stubVersionInAnOpenSession(mock(StatementResult.class), sessionMock, "neo4j-version");

    OfflineBoltStateHandler boltStateHandler = new OfflineBoltStateHandler(driverMock);

    boltStateHandler.connect();
    boltStateHandler.beginTransaction();

    // when
    boltStateHandler.reset();

    // then
    verify(sessionMock).reset();
    assertNull(boltStateHandler.getTransactionStatements());
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的package包/类
@Test
public void executeShouldPrintResult() throws CommandException {
    Driver mockedDriver = mock(Driver.class);
    Session session = mock(Session.class);
    BoltResult result = mock(BoltResult.class);

    BoltStateHandler boltStateHandler = mock(BoltStateHandler.class);

    when(boltStateHandler.isConnected()).thenReturn(true);
    when(boltStateHandler.runCypher(anyString(), anyMap())).thenReturn(Optional.of(result));
    when(mockedPrettyPrinter.format(result)).thenReturn("999");
    when(mockedDriver.session()).thenReturn(session);

    OfflineTestShell shell = new OfflineTestShell(logger, boltStateHandler, mockedPrettyPrinter);
    shell.execute("RETURN 999");
    verify(logger).printOut(contains("999"));
}
 

import org.neo4j.driver.v1.Driver; //导入依赖的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.Driver; //导入依赖的package包/类
@Test
public void bolt() throws Exception {
  new MockUnit(Env.class, Config.class, Binder.class)
      .expect(hasPath("db.url", true))
      .expect(confString("db.url", "bolt://localhost:7687"))
      .expect(hasPath("com.graphaware", false))
      .expect(hasPath("neo4j", false))
      .expect(hasPath("db", true))
      .expect(confConf("db", ConfigFactory.empty()))
      .expect(hasPath("neo4j.db", false))
      .expect(serviceKey())
      .expect(confString("db.user", "test"))
      .expect(confString("db.password", "test"))
      .expect(bolt("bolt://localhost:7687", "db", "test", "test"))
      .expect(props())
      .expect(setProp("server_root_uri", "bolt://localhost:7687"))
      .expect(boltAccess("db"))
      .expect(logdb("bolt://localhost:7687", null))
      .expect(onStop())
      .run(unit -> {
            Neo4j neo4j = new Neo4j();
            neo4j.configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
          }, closeOnStop(),
          bind(Driver.class, 0),
          bind(Session.class, 1));
}