org.neo4j.driver.v1.GraphDatabase Java Examples

@Test
public void standAloneDriver() {
    Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "12345"));
    Session session = driver.session();

    session.run("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
            "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
            "RETURN baeldung, tesla");

    StatementResult result = session.run("MATCH (company:Company)-[:owns]-> (car:Car)" +
            "WHERE car.make='tesla' and car.model='modelX'" +
            "RETURN company.name");

    Assert.assertTrue(result.hasNext());
    Assert.assertEquals(result.next().get("company.name").asString(), "Baeldung");

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

@Before
public void setUp() throws Exception {
    clientService = new Neo4JCypherClientService();
    runner = TestRunners.newTestRunner(MockProcessor.class);
    runner.addControllerService("clientService", clientService);
    runner.setProperty(clientService, Neo4JCypherClientService.USERNAME, user);
    runner.setProperty(clientService, Neo4JCypherClientService.PASSWORD, password);
    runner.enableControllerService(clientService);
    runner.setProperty(MockProcessor.CLIENT, "clientService");
    driver = GraphDatabase.driver(neo4jUrl, AuthTokens.basic(user, password));
    executeSession("match (n) detach delete n");

    StatementResult result = executeSession("match (n) return n");

    assertEquals("nodes should be equal", 0, result.list().size());
}
 

public void start() throws Exception {

        Objects.nonNull(config);
        assertThat("config.getScheme().startsWith(\"tcp\")", config.getScheme().startsWith("tcp"));

        LOGGER.info("Neo4jConfiguration.start {}", config);

        AuthToken authToken = null;
        if( StringUtils.isNotBlank(config.getUsername()) && StringUtils.isNotBlank(config.getPassword())) {
            authToken = AuthTokens.basic( config.getUsername(), config.getPassword() );
        }

        if( authToken == null ) {
            client = GraphDatabase.driver("bolt://" + config.getHosts().get(0) + ":" + config.getPort());
        } else {
            client = GraphDatabase.driver("bolt://" + config.getHosts().get(0) + ":" + config.getPort(), authToken);
        }

        Objects.nonNull(client);

    }
 

/**
 * Test {@link CyNodeLoadingHandler} to see if nodes are mapped from RDF and loaded into Neo4J
 */
@Test
public void testNodes () throws Exception
{
	try (	
		Driver neoDriver = GraphDatabase.driver( "bolt://127.0.0.1:7687", AuthTokens.basic ( "neo4j", "test" ) );
	)
	{
		Session session = neoDriver.session ( AccessMode.READ );
		StatementResult cursor = session.run ( "MATCH ( n:TestNode ) RETURN COUNT ( n ) AS ct" );
		Assert.assertEquals ( "Wrong count for TestNode", 2, cursor.next ().get ( "ct" ).asLong () );
		
		cursor = session.run ( "MATCH ( n:TestNode { iri:'" + iri ( "ex:2" ) + "'} ) RETURN properties ( n ) AS props" );
		assertTrue ( "ex:2 not returned!", cursor.hasNext () );
		
		Map<String, Object> map = cursor.next ().get ( "props" ).asMap ();
		assertEquals (  "Wrong property!", "another string", map.get ( "attrib3" ) );
	}
}
 

@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());
    }
}
 

@Override
protected Graph createGraph() {
  driver = GraphDatabase.driver(neo4jUrl, AuthTokens.basic(neo4jUsername, neo4jPassword));
  Neo4JElementIdProvider<?> vertexIdProvider = new DatabaseSequenceElementIdProvider(driver);
  Neo4JElementIdProvider<?> edgeIdProvider = new DatabaseSequenceElementIdProvider(driver);

  // create graph instance
  return new Neo4JGraph(driver, vertexIdProvider, edgeIdProvider);
}
 

private Driver getDriver() {
	if (this.driver == null) {
		String uri = this.properties.getProperty(DBProperties.SERVER_ROOT_URI);
		if (this.authToken != null)
			this.driver = GraphDatabase.driver(uri, this.authToken);
		else
			this.driver = GraphDatabase.driver(uri);
		this.shutdownHook = registerShutdownHook();
	}
	return this.driver;
}
 

private static Driver getDriver(Neo4jContainer container) {

        AuthToken authToken = AuthTokens.none();
        if (container.getAdminPassword() != null) {
            authToken = AuthTokens.basic("neo4j", container.getAdminPassword());
        }
        return GraphDatabase.driver(container.getBoltUrl(), authToken);
    }
 

@Override
protected Graph createGraph() {
  driver = GraphDatabase.driver(neo4jUrl, AuthTokens.basic(neo4jUsername, neo4jPassword));
  Neo4JElementIdProvider<?> vertexIdProvider = new DatabaseSequenceElementIdProvider(driver);
  Neo4JElementIdProvider<?> edgeIdProvider = new DatabaseSequenceElementIdProvider(driver);

  // create graph instance
  return new Neo4JGraph(driver, vertexIdProvider, edgeIdProvider);
}
 

private GraphDBConnection(String uri, String user, String password) {
	Integer maxIdleConnections = ApplicationConfigProvider.getInstance().getGraph().getMaxIdleConnections();
	if(maxIdleConnections == null) {
		maxIdleConnections = defaultMaxIdleConnections;
	}
	driver = GraphDatabase.driver( uri, AuthTokens.basic( user, password ),
									Config.build().withMaxIdleConnections(maxIdleConnections).toConfig() );
}
 

/**
 * Facility to empty the Neo4j test DB. Auto-called by other tests.
 * It's here as static method, because we call it from other clasess as well.
 */
public static void initNeo ()
{
	try (	
			Driver neoDriver = GraphDatabase.driver( "bolt://127.0.0.1:7687", AuthTokens.basic ( "neo4j", "test" ) );
			Session session = neoDriver.session ();
		)
	{
		session.run ( "MATCH (n) DETACH DELETE n" );
	}
}
 

/**
 * Loads some basic test RDF data into RDF.
 */
@Before
public void initNeoData () throws IOException
{
	initNeo ();

	try (	
			Driver neoDriver = GraphDatabase.driver( "bolt://127.0.0.1:7687", AuthTokens.basic ( "neo4j", "test" ) );
			RdfDataManager rdfMgr = new RdfDataManager ( RdfDataManagerTest.TDB_PATH );
		)
	{
		CyNodeLoadingHandler handler = new CyNodeLoadingHandler ();
		Neo4jDataManager neoMgr = new Neo4jDataManager ( neoDriver );
		
		// We need the same nodes in all tests
		handler.setRdfDataManager ( rdfMgr );
		handler.setNeo4jDataManager ( neoMgr );
		handler.setLabelsSparql ( RdfDataManagerTest.SPARQL_NODE_LABELS );
		handler.setNodePropsSparql ( RdfDataManagerTest.SPARQL_NODE_PROPS );
		
		Set<Resource> rdfNodes = 
			Stream.of ( iri ( "ex:1" ), iri ( "ex:2" ), iri ( "ex:3" ) )
			.map ( iri -> rdfMgr.getDataSet ().getDefaultModel ().createResource ( iri ) )
			.collect ( Collectors.toSet () );

		handler.accept ( rdfNodes );
	}
}
 

private DatabaseConnector() {
	driver = GraphDatabase.driver(URL);
}
 

@Test
public void testMultiConfigLoading () throws Exception
{
	try ( MultiConfigCyLoader cymloader = new MultiConfigCyLoader (); )
	{
		cymloader.setCypherLoaderFactory ( () -> 
		{
			// You don't want to do this, see #testSpring()
			
			RdfDataManager rdfMgr = new RdfDataManager ();
			Driver neoDriver = GraphDatabase.driver ( "bolt://127.0.0.1:7687", AuthTokens.basic ( "neo4j", "test" ) );
			Neo4jDataManager neoMgr = new Neo4jDataManager ( neoDriver );			
			
			CyNodeLoadingHandler cyNodeHandler = new CyNodeLoadingHandler ();
			CyRelationLoadingHandler cyRelHandler = new CyRelationLoadingHandler ();
			
			cyNodeHandler.setRdfDataManager ( rdfMgr );
			cyNodeHandler.setNeo4jDataManager ( neoMgr );
			
			cyRelHandler.setRdfDataManager ( rdfMgr );
			cyRelHandler.setNeo4jDataManager ( neoMgr );

			CyNodeLoadingProcessor cyNodeProc = new CyNodeLoadingProcessor ();
			cyNodeProc.setBatchJob ( cyNodeHandler );
			
			CyRelationLoadingProcessor cyRelProc = new CyRelationLoadingProcessor ();
			cyRelProc.setBatchJob ( cyRelHandler );

			SimpleCyLoader cyloader = new SimpleCyLoader ();
			cyloader.setCyNodeLoader ( cyNodeProc );
			cyloader.setCyRelationLoader ( cyRelProc );
			cyloader.setRdfDataManager ( rdfMgr );
			
			return cyloader;
		});

		
		List<ConfigItem> config = new LinkedList<> ();
		config.add ( new ConfigItem ( 
			"places", 
			readResource ( "dbpedia_node_iris.sparql" ), 
			readResource ( "dbpedia_node_labels.sparql" ), 
			readResource ( "dbpedia_node_props.sparql" ), 
			readResource ( "dbpedia_rel_types.sparql" ), 
			readResource ( "dbpedia_rel_props.sparql" )			 
		));
		config.add ( new ConfigItem ( 
			"people", 
			readResource ( "dbpedia_people_iris.sparql" ), 
			readResource ( "dbpedia_people_labels.sparql" ), 
			readResource ( "dbpedia_people_props.sparql" ), 
			readResource ( "dbpedia_people_rel_types.sparql" ), 
			null			 
		));
		
		cymloader.setConfigItems ( config );

		cymloader.load ( RdfDataManagerTest.TDB_PATH );
	}
	// TODO: test!
}
 

private Driver getDriver() {
  if (driver == null) {
    driver = GraphDatabase.driver(this.neo4jUrl, this.authToken, this.config);
  }
  return driver;
}
 

@Test
public void testLoading () throws Exception
{
	try (
		Driver neoDriver = GraphDatabase.driver ( "bolt://127.0.0.1:7687", AuthTokens.basic ( "neo4j", "test" ) );
		RdfDataManager rdfMgr = new RdfDataManager ( RdfDataManagerTest.TDB_PATH );
		SimpleCyLoader cyloader = new SimpleCyLoader ();
	)
	{
		// You don't want to do this, see #testSpring()

		Neo4jDataManager neoMgr = new Neo4jDataManager ( neoDriver );
		
		CyNodeLoadingHandler cyNodeHandler = new CyNodeLoadingHandler ();
		CyRelationLoadingHandler cyRelHandler = new CyRelationLoadingHandler ();
		
		cyNodeHandler.setLabelsSparql ( IOUtils.readResource ( "dbpedia_node_labels.sparql" ) );
		cyNodeHandler.setNodePropsSparql ( IOUtils.readResource ( "dbpedia_node_props.sparql" ) );
		cyNodeHandler.setRdfDataManager ( rdfMgr );
		cyNodeHandler.setNeo4jDataManager ( neoMgr );
		
		cyRelHandler.setRelationTypesSparql ( IOUtils.readResource ( "dbpedia_rel_types.sparql" ) );
		cyRelHandler.setRelationPropsSparql ( IOUtils.readResource ( "dbpedia_rel_props.sparql" ) );
		cyRelHandler.setRdfDataManager ( rdfMgr );
		cyRelHandler.setNeo4jDataManager ( neoMgr );

		CyNodeLoadingProcessor cyNodeProc = new CyNodeLoadingProcessor ();
		cyNodeProc.setNodeIrisSparql ( IOUtils.readResource ( "dbpedia_node_iris.sparql" ) );
		cyNodeProc.setBatchJob ( cyNodeHandler );
		
		CyRelationLoadingProcessor cyRelProc = new CyRelationLoadingProcessor ();
		cyRelProc.setBatchJob ( cyRelHandler );

		cyloader.setCyNodeLoader ( cyNodeProc );
		cyloader.setCyRelationLoader ( cyRelProc );
		
		cyloader.load ( RdfDataManagerTest.TDB_PATH );
		// TODO: test!
		
	} // try neoDriver
}
 

/**
 * Tests {@link CyRelationLoadingHandler} to see if relations are mapped from RDF and loaded into Neo4J.
 */
@Test
public void testRelations () throws Exception
{
	try (	
		Driver neoDriver = GraphDatabase.driver( "bolt://127.0.0.1:7687", AuthTokens.basic ( "neo4j", "test" ) );
		RdfDataManager rdfMgr = new RdfDataManager ( RdfDataManagerTest.TDB_PATH );
	)
	{
		CyRelationLoadingHandler handler = new CyRelationLoadingHandler ();
		Neo4jDataManager neoMgr = new Neo4jDataManager ( neoDriver );

		handler.setRdfDataManager ( rdfMgr );
		handler.setNeo4jDataManager ( neoMgr );
		handler.setRelationTypesSparql ( RdfDataManagerTest.SPARQL_REL_TYPES );
		handler.setRelationPropsSparql ( RdfDataManagerTest.SPARQL_REL_PROPS  );

		Set<QuerySolution> relSparqlRows = new HashSet<> ();
		Dataset dataSet = rdfMgr.getDataSet ();
		Txn.executeRead ( dataSet,  () ->
			SparqlUtils.select ( RdfDataManagerTest.SPARQL_REL_TYPES, rdfMgr.getDataSet ().getDefaultModel () )
				.forEachRemaining ( row -> relSparqlRows.add ( row ) )
		);

		handler.accept ( relSparqlRows );

		// Verify
		
		CypherTester tester = new CypherTester ( neoMgr );
		
		Assert.assertTrue (
			"Wrong count for relations",
			tester.ask ( "MATCH ()-[r]->() RETURN COUNT ( r ) = 3" )
		);

		Assert.assertTrue (
			"Wrong count for {1 relatedTo 2}!",
			tester.ask ( 
				"MATCH p = (:TestNode{ iri:$iri1 })-[:relatedTo]->(:TestNode{ iri:$iri2 }) RETURN COUNT ( p ) = 1",
				"iri1", iri ( "ex:1" ), "iri2", iri ( "ex:2" )
			)
		);
		
		Assert.assertTrue (
			"Wrong count for {3 derivedFrom 1}!",
			tester.ask ( 
				"MATCH p = (:SuperTestNode{ iri:$iri1 })-[:derivedFrom]->(:TestNode{ iri:$iri2 }) RETURN COUNT ( p ) = 1",
				"iri1", iri ( "ex:3" ), "iri2", iri ( "ex:1" )
			)
		);

		Assert.assertTrue (
			"Wrong count for {3 derivedFrom 1}!",
			tester.ask ( 
				"MATCH p = (:SuperTestNode{ iri:$iri1 })-[:derivedFrom]->(:TestNode{ iri:$iri2 }) RETURN COUNT ( p ) = 1",
				"iri1", iri ( "ex:3" ), "iri2", iri ( "ex:1" )
			)
		);

		Assert.assertTrue (
			"Wrong count for {3 derivedFrom 1}!",
			tester.ask ( 
				"MATCH p = (:SuperTestNode{ iri:$iri1 })-[:derivedFrom]->(:TestNode{ iri:$iri2 }) RETURN COUNT ( p ) = 1",
				"iri1", iri ( "ex:3" ), "iri2", iri ( "ex:1" )
			)
		);
		
		
		Assert.assertTrue (
			"reified relation, wrong property value for 'note'!",
			tester.compare (
				// Test against the Cypher result
				notesv -> {
					List<Object> notes = notesv.asList ();
					if ( notes == null || notes.isEmpty () ) return false;

					// notes collection is sorted, then compared to the sorted values in the reference
					return notes
						.stream ()
						.sorted ()
						.collect ( Collectors.toList () )
						.equals ( 
							Arrays.asList ( new String[] { "Another Note", "Reified Relation" } )
						);
				},
				// the relation containing .note
				"MATCH (:TestNode{ iri:$iri1 })-[r:relatedTo]->(:AdditionalLabel{ iri:$iri2 })\n"
				+ "RETURN r.note\n",
				"iri1", iri ( "ex:2" ), "iri2", iri ( "ex:3" )
			)
		);
	} // try
}
 

protected Driver getDriver(ConfigurationContext context) {
    connectionUrl = context.getProperty(CONNECTION_URL).evaluateAttributeExpressions().getValue();
    username = context.getProperty(USERNAME).evaluateAttributeExpressions().getValue();
    password = context.getProperty(PASSWORD).getValue();

    Config.ConfigBuilder configBuilder = Config.build();
    String loadBalancingStrategyValue = context.getProperty(LOAD_BALANCING_STRATEGY).getValue();
    if ( ! StringUtils.isBlank(loadBalancingStrategyValue) ) {
        configBuilder = configBuilder.withLoadBalancingStrategy(
                Config.LoadBalancingStrategy.valueOf(loadBalancingStrategyValue));
    }

    configBuilder.withMaxConnectionPoolSize(context.getProperty(MAX_CONNECTION_POOL_SIZE).evaluateAttributeExpressions().asInteger());

    configBuilder.withConnectionTimeout(context.getProperty(CONNECTION_TIMEOUT).evaluateAttributeExpressions().asTimePeriod(TimeUnit.SECONDS), TimeUnit.SECONDS);

    configBuilder.withConnectionAcquisitionTimeout(context.getProperty(MAX_CONNECTION_ACQUISITION_TIMEOUT).evaluateAttributeExpressions().asTimePeriod(TimeUnit.SECONDS), TimeUnit.SECONDS);

    configBuilder.withMaxConnectionLifetime(context.getProperty(MAX_CONNECTION_LIFETIME).evaluateAttributeExpressions().asTimePeriod(TimeUnit.SECONDS), TimeUnit.SECONDS);

    configBuilder.withConnectionLivenessCheckTimeout(context.getProperty(IDLE_TIME_BEFORE_CONNECTION_TEST).evaluateAttributeExpressions().asTimePeriod(TimeUnit.SECONDS), TimeUnit.SECONDS);

    if ( context.getProperty(ENCRYPTION).asBoolean() ) {
        configBuilder.withEncryption();
    } else {
        configBuilder.withoutEncryption();
    }

    final SSLContextService sslService = context.getProperty(SSL_CONTEXT_SERVICE).asControllerService(SSLContextService.class);
    if (sslService != null) {
        if ( sslService.isTrustStoreConfigured()) {
            configBuilder.withTrustStrategy(Config.TrustStrategy.trustCustomCertificateSignedBy(new File(
                    sslService.getTrustStoreFile())));
        } else {
            configBuilder.withTrustStrategy(Config.TrustStrategy.trustSystemCertificates());
        }
    }

    return GraphDatabase.driver( connectionUrl, AuthTokens.basic( username, password),
            configBuilder.toConfig());
}
 

public DatabaseTestConnector() {
	driver = GraphDatabase.driver("bolt://neo4j:7687");
}
 

private DatabaseConnector(String URL) {
	DatabaseConnector.URL = URL;
	driver = GraphDatabase.driver(URL);
}