Java GraphDatabaseAPI类代码示例

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Test
public void failureToCreateAnIndexShouldNotLeaveConfigurationBehind() throws Exception
{
    // WHEN
    try
    {
        // PerFieldAnalyzerWrapper is invalid since it has no public no-arg constructor
        nodeIndex( stringMap( "analyzer", PerFieldAnalyzerWrapper.class.getName() ) );
        fail( "Should have failed" );
    }
    catch ( RuntimeException e )
    {
        assertThat( e.getMessage(), CoreMatchers.containsString( PerFieldAnalyzerWrapper.class.getName() ) );
    }

    // THEN - assert that there's no index config about this index left behind
    assertFalse( "There should be no index config for index '" + currentIndexName() + "' left behind",
            ((GraphDatabaseAPI)graphDb).getDependencyResolver().resolveDependency( IndexConfigStore.class ).has(
                    Node.class, currentIndexName() ) );
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Before
public void setUp() throws IOException, InterruptedException
{
    database = new TestGraphDatabaseFactory().newImpermanentDatabase();
    Runtime.getRuntime().addShutdownHook(new Thread()
    {
        @Override
        public void run()
        {
            database.shutdown();
        }
    });
    ServerConfigurator configurator = new ServerConfigurator((GraphDatabaseAPI) database);
    int port = neoServerPort();
    configurator.configuration().addProperty(Configurator.WEBSERVER_PORT_PROPERTY_KEY, port);
    configurator.configuration().addProperty("dbms.security.auth_enabled", false);
    bootstrapper = new WrappingNeoServerBootstrapper((GraphDatabaseAPI) database, configurator);
    bootstrapper.start();
    while (!bootstrapper.getServer().getDatabase().isRunning())
    {
        // It's ok to spin here.. it's not production code.
        Thread.sleep(250);
    }
    client = new Neo4jClient("http://localhost:" + port + "/db/data");
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
/**
 * use this in web browser:
 * :config maxNeighbours: 200
 * */
@SuppressWarnings("deprecation")
private void DoBootstrap()
{
	ServerConfigurator config
		= new ServerConfigurator((GraphDatabaseAPI)graph_db);

	config.configuration()
		.setProperty(Configurator.WEBSERVER_ADDRESS_PROPERTY_KEY, "0.0.0.0");

	config.configuration()
		.setProperty(Configurator.WEBSERVER_PORT_PROPERTY_KEY, webserver_port);

	webserver = new WrappingNeoServerBootstrapper((GraphDatabaseAPI) graph_db, config);
	webserver.start();

	LOGGER.log(Level.INFO, "neo4j is accessible through the web");
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Name("execute_script")
@Description("execute a Gremlin script with 'g' set to the Neo4j2Graph and 'results' containing the results. Only results of one object type is supported.")
@PluginTarget(GraphDatabaseService.class)
public Representation executeScript(
        @Source final GraphDatabaseService neo4j,
        @Description("The Gremlin script") @Parameter(name = "script", optional = false) final String script,
        @Description("JSON Map of additional parameters for script variables") @Parameter(name = "params", optional = true) final Map params ) throws BadInputException
{
    Neo4j2Graph neo4jGraph = getOrCreateGremlin( (GraphDatabaseAPI) neo4j );
    try(Transaction tx = neo4j.beginTx())
    {
        engineReplacementDecision.beforeExecution( script );
        final Bindings bindings = createBindings(params, neo4jGraph);
        final Object result = engine().eval( script, bindings );
        Representation representation = GremlinObjectToRepresentationConverter.convert(result);
        tx.success();
        return representation;
    }
    catch ( final Exception e )
    {
     throw new BadInputException( e.getMessage(), e );
    }
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
public Node getOrCreate(String nodeId)
{
    Node result = null;

    try(final Transaction tx = ((GraphDatabaseAPI) neo4jGraph).tx().unforced().begin())
    {
        try
        {
            String queryString = "MERGE (n:Node {nodeId: {nodeId}}) RETURN n";
            Map<String, Object> parameters = new HashMap<String, Object>();
            parameters.put("nodeId", nodeId);
            ResourceIterator<Node> resultIterator = engine.execute(queryString, parameters).columnAs("n");
            result = resultIterator.next();
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get or create node " + nodeId, e);
        }
    }

    return result;
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Override
public void relateNodes(Node src, Node dest)
{
    try (final Transaction tx = ((GraphDatabaseAPI) neo4jGraph).tx().unforced().begin())
    {
        try
        {
            src.createRelationshipTo(dest, Neo4jGraphDatabase.RelTypes.SIMILAR);
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to relate nodes", e);
        }
    }
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Test
public void shouldLoadAndUseLuceneProvider() throws Exception
{
    // GIVEN
    File storeDir = testDirectory.graphDbDir();
    BatchInserter inserter = BatchInserters.inserter( storeDir );
    inserter.createDeferredSchemaIndex( LABEL ).on( "name" ).create();

    // WHEN
    inserter.createNode( map( "name", "Mattias" ), LABEL );
    inserter.shutdown();

    // THEN
    GraphDatabaseFactory graphDatabaseFactory = new TestGraphDatabaseFactory();
    GraphDatabaseAPI db = (GraphDatabaseAPI) graphDatabaseFactory.newEmbeddedDatabase( storeDir );
    DependencyResolver dependencyResolver = db.getDependencyResolver();
    SchemaIndexProvider schemaIndexProvider = dependencyResolver.resolveDependency(
            SchemaIndexProvider.class,
            SchemaIndexProvider.HIGHEST_PRIORITIZED_OR_NONE );

    // assert the indexProvider is a Lucene one
    try ( Transaction ignore = db.beginTx() )
    {
        IndexDefinition indexDefinition = single( db.schema().getIndexes( LABEL ) );
        assertThat( db.schema().getIndexState( indexDefinition ), is( Schema.IndexState.ONLINE ) );
        assertThat( schemaIndexProvider, instanceOf( LuceneSchemaIndexProvider.class ) );
    }

    // CLEANUP
    db.shutdown();
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Before
public void before()
{
    List<KernelExtensionFactory<?>> extensionFactories = new ArrayList<>();
    extensionFactories.add( kernelExtensionFactory );
    extensionFactories.add(new LuceneLabelScanStoreExtension());
    factory.setKernelExtensions( extensionFactories );
    db = (GraphDatabaseAPI) factory.newEmbeddedDatabase( storeDir.absolutePath() );
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Test
public void shouldNotLeaveLuceneIndexFilesHangingAroundIfConstraintCreationFails()
{
    // given
    GraphDatabaseAPI db = dbRule.getGraphDatabaseAPI();

    try ( Transaction tx = db.beginTx() )
    {
        for ( int i = 0; i < 2; i++ )
        {
            Node node1 = db.createNode( LABEL );
            node1.setProperty( "prop", true );
        }

        tx.success();
    }

    // when
    try ( Transaction tx = db.beginTx() )
    {
        db.schema().constraintFor( LABEL ).assertPropertyIsUnique( "prop" ).create();
        fail("Should have failed with ConstraintViolationException");
        tx.success();
    }
    catch ( ConstraintViolationException ignored )  { }

    // then
    try(Transaction ignore = db.beginTx())
    {
        assertEquals(0, Iterables.count(db.schema().getIndexes() ));
    }

    File schemaStorePath = SchemaIndexProvider
            .getRootDirectory( new File( db.getStoreDir() ), LuceneSchemaIndexProviderFactory.KEY );

    String indexId = "1";
    File[] files = new File(schemaStorePath, indexId ).listFiles();
    assertNotNull( files );
    assertEquals(0, files.length);
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Override
public void findNodesOfAllEdges() {
    Object tx = null;
    if(GraphDatabaseType.NEO4J == type) {//TODO fix this
        tx = ((GraphDatabaseAPI) ((Neo4jGraphDatabase) this).neo4jGraph).tx().unforced().begin();
    }
    try {
        
        EdgeIteratorType edgeIterator;
        Timer.Context ctxt = getAllEdgesTimes.time();
        try {
            edgeIterator = this.getAllEdges();
        } finally {
            ctxt.stop();
        }
        
        while(edgeIteratorHasNext(edgeIterator)) {
            EdgeType edge;
            ctxt = nextEdgeTimes.time();
            try {
                edge = nextEdge(edgeIterator);
            } finally {
                ctxt.stop();
            }
            @SuppressWarnings("unused")
            VertexType source = this.getSrcVertexFromEdge(edge);
            @SuppressWarnings("unused")
            VertexType destination = this.getDestVertexFromEdge(edge);
        }
    } finally {//TODO fix this
        if(GraphDatabaseType.NEO4J == type) {
            ((Transaction) tx).close();
        }
    }
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Before
public void before() throws Exception
{
    db = (GraphDatabaseAPI) new TestGraphDatabaseFactory().newEmbeddedDatabase( testDirectory.graphDbDir() );
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Before
public void startDb()
{
    graphDb = (GraphDatabaseAPI) new TestGraphDatabaseFactory().
            newImpermanentDatabaseBuilder().setConfig( getConfig() ).newGraphDatabase();
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@BeforeClass
public static void doBefore() throws IOException
{
    FileUtils.deleteRecursively( new File( "target/test-data/deletion" ) );
    db = (GraphDatabaseAPI) new TestGraphDatabaseFactory().newEmbeddedDatabase( "target/test-data/deletion" );
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
@Test
public void shouldNotAllowConcurrentViolationOfConstraint() throws Exception
{
    // Given
    GraphDatabaseAPI graphDb = db.getGraphDatabaseAPI();

    Supplier<Statement> statementSupplier = graphDb.getDependencyResolver()
            .resolveDependency( ThreadToStatementContextBridge.class );

    Label label = label( "Foo" );
    String propertyKey = "bar";
    String conflictingValue = "baz";

    // a constraint
    try ( Transaction tx = graphDb.beginTx() )
    {
        graphDb.schema().constraintFor( label ).assertPropertyIsUnique( propertyKey ).create();
        tx.success();
    }

    // When
    try ( Transaction tx = graphDb.beginTx() )
    {
        // create a statement and perform a lookup
        Statement statement = statementSupplier.get();
        int labelId = statement.readOperations().labelGetForName( label.name() );
        int propertyKeyId = statement.readOperations().propertyKeyGetForName( propertyKey );
        statement.readOperations().nodesGetFromIndexSeek( new IndexDescriptor( labelId, propertyKeyId ),
                "The value is irrelevant, we just want to perform some sort of lookup against this index" );

        // then let another thread come in and create a node
        threads.execute( createNode( label, propertyKey, conflictingValue ), graphDb ).get();

        // before we create a node with the same property ourselves - using the same statement that we have
        // already used for lookup against that very same index
        long node = statement.dataWriteOperations().nodeCreate();
        statement.dataWriteOperations().nodeAddLabel( node, labelId );
        try
        {
            statement.dataWriteOperations().nodeSetProperty( node, property( propertyKeyId, conflictingValue ) );

            fail( "exception expected" );
        }
        // Then
        catch ( UniquePropertyConstraintViolationKernelException e )
        {
            assertEquals( labelId, e.labelId() );
            assertEquals( propertyKeyId, e.propertyKeyId() );
            assertEquals( conflictingValue, e.propertyValue() );
        }

        tx.success();
    }
}
 

import org.neo4j.kernel.GraphDatabaseAPI; //导入依赖的package包/类
private Transaction beginUnforcedTransaction() {
    final TransactionBuilder builder = ((GraphDatabaseAPI) neo4jGraph).tx().unforced();
    return builder.begin();
}