InternalAbstractGraphDatabase (Neo4j - Graph Database Kernel 2.0.0-M03 API)

java.lang.Object
- org.neo4j.kernel.AbstractGraphDatabase
- - org.neo4j.kernel.InternalAbstractGraphDatabase

All Implemented Interfaces:

GraphDatabaseService, GraphDatabaseAPI

Direct Known Subclasses:

EmbeddedGraphDatabase, EmbeddedReadOnlyGraphDatabase
```
public abstract class InternalAbstractGraphDatabase
extends AbstractGraphDatabase
implements GraphDatabaseService, GraphDatabaseAPI
```
Base implementation of GraphDatabaseService. Responsible for creating services, handling dependencies between them, and lifecycle management of these.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class InternalAbstractGraphDatabase.Configuration

protected class InternalAbstractGraphDatabase.DefaultKernelData

Nested Classes
Modifier and Type	Class and Description
`static class`	`InternalAbstractGraphDatabase.Configuration`
`protected class`	`InternalAbstractGraphDatabase.DefaultKernelData`

Field Summary

Fields
Modifier and Type	Field and Description
`protected BridgingCacheAccess`	`cacheBridge`
`protected org.neo4j.kernel.impl.core.Caches`	`caches`
`protected org.neo4j.kernel.impl.cleanup.CleanupService`	`cleanupService`
`protected Config`	`config`
`protected DependencyResolver`	`dependencyResolver`
`protected DiagnosticsManager`	`diagnosticsManager`
`protected KernelData`	`extensions`
`protected org.neo4j.kernel.impl.nioneo.store.FileSystemAbstraction`	`fileSystem`
`protected Guard`	`guard`
`protected IdGeneratorFactory`	`idGeneratorFactory`
`protected org.neo4j.kernel.IndexManagerImpl`	`indexManager`
`protected org.neo4j.kernel.impl.index.IndexStore`	`indexStore`
`protected org.neo4j.kernel.impl.util.JobScheduler`	`jobScheduler`
`protected KernelAPI`	`kernelAPI`
`protected KernelEventHandlers`	`kernelEventHandlers`
`protected org.neo4j.kernel.impl.core.KernelPanicEventGenerator`	`kernelPanicEventGenerator`
`protected org.neo4j.kernel.impl.core.LabelTokenHolder`	`labelTokenHolder`
`protected LifeSupport`	`life`
`protected org.neo4j.kernel.impl.transaction.LockManager`	`lockManager`
`protected org.neo4j.kernel.impl.transaction.xaframework.LogBufferFactory`	`logBufferFactory`
`protected Logging`	`logging`
`protected org.neo4j.kernel.impl.util.StringLogger`	`msgLog`
`protected org.neo4j.kernel.impl.nioneo.xa.NeoStoreXaDataSource`	`neoDataSource`
`protected org.neo4j.kernel.NodeAutoIndexerImpl`	`nodeAutoIndexer`
`protected org.neo4j.kernel.impl.core.NodeManager`	`nodeManager`
`protected Map<String,String>`	`params`
`protected org.neo4j.kernel.impl.persistence.PersistenceManager`	`persistenceManager`
`protected org.neo4j.kernel.impl.nioneo.xa.NioNeoDbPersistenceSource`	`persistenceSource`
`protected org.neo4j.kernel.impl.core.PropertyKeyTokenHolder`	`propertyKeyTokenHolder`
`protected org.neo4j.kernel.impl.transaction.xaframework.RecoveryVerifier`	`recoveryVerifier`
`protected org.neo4j.kernel.impl.core.TokenCreator`	`relationshipTypeCreator`
`protected org.neo4j.kernel.impl.core.RelationshipTypeTokenHolder`	`relationshipTypeTokenHolder`
`protected org.neo4j.kernel.RelationshipAutoIndexerImpl`	`relAutoIndexer`
`protected Schema`	`schema`
`protected org.neo4j.kernel.impl.transaction.TransactionStateFactory`	`stateFactory`
`protected ThreadToStatementContextBridge`	`statementContextProvider`
`protected File`	`storeDir`
`protected org.neo4j.kernel.impl.nioneo.store.StoreFactory`	`storeFactory`
`protected org.neo4j.kernel.impl.nioneo.store.StoreId`	`storeId`
`protected StoreLockerLifecycleAdapter`	`storeLocker`
`protected org.neo4j.kernel.impl.core.TxEventSyncHookFactory`	`syncHook`
`protected TransactionEventHandlers`	`transactionEventHandlers`
`protected org.neo4j.kernel.impl.transaction.TxHook`	`txHook`
`protected org.neo4j.kernel.impl.transaction.xaframework.TxIdGenerator`	`txIdGenerator`
`protected org.neo4j.kernel.impl.transaction.AbstractTransactionManager`	`txManager`
`protected org.neo4j.kernel.impl.api.UpdateableSchemaState`	`updateableSchemaState`
`protected org.neo4j.kernel.impl.transaction.XaDataSourceManager`	`xaDataSourceManager`
`protected org.neo4j.kernel.impl.transaction.xaframework.XaFactory`	`xaFactory`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`InternalAbstractGraphDatabase(String storeDir, Map<String,String> params, Iterable<Class<?>> settingsClasses, Iterable<IndexProvider> indexProviders, Iterable<KernelExtensionFactory<?>> kernelExtensions, Iterable<org.neo4j.kernel.impl.cache.CacheProvider> cacheProviders, Iterable<org.neo4j.kernel.impl.transaction.xaframework.TransactionInterceptorProvider> transactionInterceptorProviders)`

Method Summary

Methods
Modifier and Type	Method and Description
`Transaction`	`beginTx()` Starts a new `transaction` and associates it with the current thread.
`protected Transaction`	`beginTx(org.neo4j.kernel.impl.transaction.xaframework.ForceMode forceMode)`
`protected void`	`create()`
`protected org.neo4j.kernel.impl.core.Caches`	`createCaches()`
`protected org.neo4j.kernel.impl.cleanup.CleanupService`	`createCleanupService()`
`protected org.neo4j.kernel.impl.nioneo.store.FileSystemAbstraction`	`createFileSystemAbstraction()`
`protected IdGeneratorFactory`	`createIdGeneratorFactory()`
`protected KernelData`	`createKernelData()`
`protected org.neo4j.kernel.impl.core.TokenCreator`	`createLabelIdCreator()`
`protected org.neo4j.kernel.impl.transaction.LockManager`	`createLockManager()`
`protected Logging`	`createLogging()`
`protected void`	`createNeoDataSource()`
`Node`	`createNode()` Creates a new node.
`Node`	`createNode(Label... labels)` Creates a new node and adds the provided labels to it.
`protected org.neo4j.kernel.impl.core.NodeProxy.NodeLookup`	`createNodeLookup()`
`protected org.neo4j.kernel.impl.core.TokenCreator`	`createPropertyKeyCreator()`
`protected org.neo4j.kernel.impl.transaction.xaframework.RecoveryVerifier`	`createRecoveryVerifier()`
`protected org.neo4j.kernel.impl.core.RelationshipProxy.RelationshipLookups`	`createRelationshipLookups()`
`protected org.neo4j.kernel.impl.core.TokenCreator`	`createRelationshipTypeCreator()`
`protected org.neo4j.kernel.impl.nioneo.store.StoreFactory`	`createStoreFactory()`
`protected org.neo4j.kernel.impl.transaction.TransactionStateFactory`	`createTransactionStateFactory()`
`protected org.neo4j.kernel.impl.transaction.TxHook`	`createTxHook()`
`protected org.neo4j.kernel.impl.transaction.xaframework.TxIdGenerator`	`createTxIdGenerator()`
`protected org.neo4j.kernel.impl.transaction.XaDataSourceManager`	`createXaDataSourceManager()`
`protected void`	`doAfterRecoveryAndStartup(boolean isMaster)`
`boolean`	`equals(Object o)`
`ResourceIterable<Node>`	`findNodesByLabelAndProperty(Label myLabel, String key, Object value)` Returns all nodes having the label, and the wanted property value.
`Iterable<Node>`	`getAllNodes()` Returns all nodes in the graph.
`Config`	`getConfig()`
`DependencyResolver`	`getDependencyResolver()`
`DiagnosticsManager`	`getDiagnosticsManager()`
`Guard`	`getGuard()`
`IdGeneratorFactory`	`getIdGeneratorFactory()`
`KernelData`	`getKernelData()`
`org.neo4j.kernel.impl.core.KernelPanicEventGenerator`	`getKernelPanicGenerator()`
`org.neo4j.kernel.impl.transaction.LockManager`	`getLockManager()`
`org.neo4j.kernel.impl.util.StringLogger`	`getMessageLog()`
`Node`	`getNodeById(long id)` Looks up a node by id.
`org.neo4j.kernel.impl.core.NodeManager`	`getNodeManager()`
`org.neo4j.kernel.impl.persistence.PersistenceSource`	`getPersistenceSource()`
`Node`	`getReferenceNode()` Returns the reference node, which is a "starting point" in the node space.
`Relationship`	`getRelationshipById(long id)` Looks up a relationship by id.
`Iterable<RelationshipType>`	`getRelationshipTypes()` Returns all relationship types currently in the underlying store.
`org.neo4j.kernel.impl.core.RelationshipTypeTokenHolder`	`getRelationshipTypeTokenHolder()`
`String`	`getStoreDir()`
`org.neo4j.kernel.impl.nioneo.store.StoreId`	`getStoreId()`
`org.neo4j.kernel.impl.transaction.xaframework.TxIdGenerator`	`getTxIdGenerator()`
`TransactionManager`	`getTxManager()`
`org.neo4j.kernel.impl.transaction.XaDataSourceManager`	`getXaDataSourceManager()`
`int`	`hashCode()`
`IndexManager`	`index()` Returns the `IndexManager` paired with this graph database service and is the entry point for managing indexes coupled with this database.
`protected boolean`	`isEphemeral()`
`protected abstract boolean`	`isHighlyAvailable()`
`KernelEventHandler`	`registerKernelEventHandler(KernelEventHandler handler)` Registers `handler` as a handler for kernel events which are generated from different places in the lifecycle of the kernel.
`protected void`	`registerRecovery()`
`<T> TransactionEventHandler<T>`	`registerTransactionEventHandler(TransactionEventHandler<T> handler)` Registers `handler` as a handler for transaction events which are generated from different places in the lifecycle of each transaction.
`protected void`	`run()`
`Schema`	`schema()` Returns the `schema manager` where all things related to schema, for example constraints and indexing on `labels`.
`void`	`shutdown()` Shuts down Neo4j.
`String`	`toString()`
`boolean`	`transactionRunning()`
`TransactionBuilder`	`tx()`
`KernelEventHandler`	`unregisterKernelEventHandler(KernelEventHandler handler)` Unregisters `handler` from the list of kernel event handlers.
`<T> TransactionEventHandler<T>`	`unregisterTransactionEventHandler(TransactionEventHandler<T> handler)` Unregisters `handler` from the list of transaction event handlers.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - storeDir
```
protected File storeDir
```
  - params
```
protected Map<String,String> params
```
  - storeId
```
protected org.neo4j.kernel.impl.nioneo.store.StoreId storeId
```
  - config
```
protected Config config
```
  - dependencyResolver
```
protected DependencyResolver dependencyResolver
```
  - logging
```
protected Logging logging
```
  - msgLog
```
protected org.neo4j.kernel.impl.util.StringLogger msgLog
```
  - storeLocker
```
protected StoreLockerLifecycleAdapter storeLocker
```
  - kernelEventHandlers
```
protected KernelEventHandlers kernelEventHandlers
```
  - transactionEventHandlers
```
protected TransactionEventHandlers transactionEventHandlers
```
  - relationshipTypeTokenHolder
```
protected org.neo4j.kernel.impl.core.RelationshipTypeTokenHolder relationshipTypeTokenHolder
```
  - nodeManager
```
protected org.neo4j.kernel.impl.core.NodeManager nodeManager
```
  - indexManager
```
protected org.neo4j.kernel.IndexManagerImpl indexManager
```
  - schema
```
protected Schema schema
```
  - kernelPanicEventGenerator
```
protected org.neo4j.kernel.impl.core.KernelPanicEventGenerator kernelPanicEventGenerator
```
  - txHook
```
protected org.neo4j.kernel.impl.transaction.TxHook txHook
```
  - fileSystem
```
protected org.neo4j.kernel.impl.nioneo.store.FileSystemAbstraction fileSystem
```
  - xaDataSourceManager
```
protected org.neo4j.kernel.impl.transaction.XaDataSourceManager xaDataSourceManager
```
  - lockManager
```
protected org.neo4j.kernel.impl.transaction.LockManager lockManager
```
  - idGeneratorFactory
```
protected IdGeneratorFactory idGeneratorFactory
```
  - relationshipTypeCreator
```
protected org.neo4j.kernel.impl.core.TokenCreator relationshipTypeCreator
```
  - persistenceSource
```
protected org.neo4j.kernel.impl.nioneo.xa.NioNeoDbPersistenceSource persistenceSource
```
  - syncHook
```
protected org.neo4j.kernel.impl.core.TxEventSyncHookFactory syncHook
```
  - persistenceManager
```
protected org.neo4j.kernel.impl.persistence.PersistenceManager persistenceManager
```
  - propertyKeyTokenHolder
```
protected org.neo4j.kernel.impl.core.PropertyKeyTokenHolder propertyKeyTokenHolder
```
  - labelTokenHolder
```
protected org.neo4j.kernel.impl.core.LabelTokenHolder labelTokenHolder
```
  - indexStore
```
protected org.neo4j.kernel.impl.index.IndexStore indexStore
```
  - logBufferFactory
```
protected org.neo4j.kernel.impl.transaction.xaframework.LogBufferFactory logBufferFactory
```
  - txManager
```
protected org.neo4j.kernel.impl.transaction.AbstractTransactionManager txManager
```
  - txIdGenerator
```
protected org.neo4j.kernel.impl.transaction.xaframework.TxIdGenerator txIdGenerator
```
  - storeFactory
```
protected org.neo4j.kernel.impl.nioneo.store.StoreFactory storeFactory
```
  - xaFactory
```
protected org.neo4j.kernel.impl.transaction.xaframework.XaFactory xaFactory
```
  - diagnosticsManager
```
protected DiagnosticsManager diagnosticsManager
```
  - neoDataSource
```
protected org.neo4j.kernel.impl.nioneo.xa.NeoStoreXaDataSource neoDataSource
```
  - recoveryVerifier
```
protected org.neo4j.kernel.impl.transaction.xaframework.RecoveryVerifier recoveryVerifier
```
  - guard
```
protected Guard guard
```
  - nodeAutoIndexer
```
protected org.neo4j.kernel.NodeAutoIndexerImpl nodeAutoIndexer
```
  - relAutoIndexer
```
protected org.neo4j.kernel.RelationshipAutoIndexerImpl relAutoIndexer
```
  - extensions
```
protected KernelData extensions
```
  - caches
```
protected org.neo4j.kernel.impl.core.Caches caches
```
  - stateFactory
```
protected org.neo4j.kernel.impl.transaction.TransactionStateFactory stateFactory
```
  - kernelAPI
```
protected KernelAPI kernelAPI
```
  - statementContextProvider
```
protected ThreadToStatementContextBridge statementContextProvider
```
  - cacheBridge
```
protected BridgingCacheAccess cacheBridge
```
  - jobScheduler
```
protected org.neo4j.kernel.impl.util.JobScheduler jobScheduler
```
  - updateableSchemaState
```
protected org.neo4j.kernel.impl.api.UpdateableSchemaState updateableSchemaState
```
  - cleanupService
```
protected org.neo4j.kernel.impl.cleanup.CleanupService cleanupService
```
  - life
```
protected final LifeSupport life
```
- Constructor Detail
  - InternalAbstractGraphDatabase
```
protected InternalAbstractGraphDatabase(String storeDir,
                             Map<String,String> params,
                             Iterable<Class<?>> settingsClasses,
                             Iterable<IndexProvider> indexProviders,
                             Iterable<KernelExtensionFactory<?>> kernelExtensions,
                             Iterable<org.neo4j.kernel.impl.cache.CacheProvider> cacheProviders,
                             Iterable<org.neo4j.kernel.impl.transaction.xaframework.TransactionInterceptorProvider> transactionInterceptorProviders)
```
- Method Detail
  - run
```
protected void run()
```
  - registerRecovery
```
protected void registerRecovery()
```
  - doAfterRecoveryAndStartup
```
protected void doAfterRecoveryAndStartup(boolean isMaster)
```
  - create
```
protected void create()
```
  - isHighlyAvailable
```
protected abstract boolean isHighlyAvailable()
```
  - createCleanupService
```
protected org.neo4j.kernel.impl.cleanup.CleanupService createCleanupService()
```
  - createTransactionStateFactory
```
protected org.neo4j.kernel.impl.transaction.TransactionStateFactory createTransactionStateFactory()
```
  - createXaDataSourceManager
```
protected org.neo4j.kernel.impl.transaction.XaDataSourceManager createXaDataSourceManager()
```
  - getDependencyResolver
```
public DependencyResolver getDependencyResolver()
```
    Specified by:
    
    getDependencyResolver in interface GraphDatabaseAPI
  - createRelationshipTypeCreator
```
protected org.neo4j.kernel.impl.core.TokenCreator createRelationshipTypeCreator()
```
  - createPropertyKeyCreator
```
protected org.neo4j.kernel.impl.core.TokenCreator createPropertyKeyCreator()
```
  - createLabelIdCreator
```
protected org.neo4j.kernel.impl.core.TokenCreator createLabelIdCreator()
```
  - shutdown
```
public void shutdown()
```
    Description copied from interface: GraphDatabaseService
    
    Shuts down Neo4j. After this method has been invoked, it's invalid to invoke any methods in the Neo4j API and all references to this instance of GraphDatabaseService should be discarded.
    
    Specified by:
    
    shutdown in interface GraphDatabaseService
  - createStoreFactory
```
protected org.neo4j.kernel.impl.nioneo.store.StoreFactory createStoreFactory()
```
  - createRecoveryVerifier
```
protected org.neo4j.kernel.impl.transaction.xaframework.RecoveryVerifier createRecoveryVerifier()
```
  - createKernelData
```
protected KernelData createKernelData()
```
  - createTxIdGenerator
```
protected org.neo4j.kernel.impl.transaction.xaframework.TxIdGenerator createTxIdGenerator()
```
  - createCaches
```
protected org.neo4j.kernel.impl.core.Caches createCaches()
```
  - createRelationshipLookups
```
protected org.neo4j.kernel.impl.core.RelationshipProxy.RelationshipLookups createRelationshipLookups()
```
  - createNodeLookup
```
protected org.neo4j.kernel.impl.core.NodeProxy.NodeLookup createNodeLookup()
```
  - createTxHook
```
protected org.neo4j.kernel.impl.transaction.TxHook createTxHook()
```
  - createFileSystemAbstraction
```
protected org.neo4j.kernel.impl.nioneo.store.FileSystemAbstraction createFileSystemAbstraction()
```
  - createIdGeneratorFactory
```
protected IdGeneratorFactory createIdGeneratorFactory()
```
  - createLockManager
```
protected org.neo4j.kernel.impl.transaction.LockManager createLockManager()
```
  - createLogging
```
protected Logging createLogging()
```
  - createNeoDataSource
```
protected void createNeoDataSource()
```
  - getStoreDir
```
public final String getStoreDir()
```
    Specified by:
    
    getStoreDir in interface GraphDatabaseAPI
  - getStoreId
```
public org.neo4j.kernel.impl.nioneo.store.StoreId getStoreId()
```
    Specified by:
    
    getStoreId in interface GraphDatabaseAPI
  - beginTx
```
public Transaction beginTx()
```
    Description copied from interface: GraphDatabaseService
    
    Starts a new transaction and associates it with the current thread.
    All database operations that modify the graph must be wrapped in a transaction.
    If you attempt to modify the graph outside of a transaction, those operations will throw NotInTransactionException.
    Transactions are not required for read-only operations, however it is recommended to enclose read only operations in a transaction, because the database can be more intelligent about managing resources. In particular, returned ResourceIterables will be automatically released at the end of a transaction.
    If you execute read-only operations outside of a transaction, please take care that any returned ResourceIterables are closed correctly to avoid potential blocking of write operations.
    
    Specified by:
    
    beginTx in interface GraphDatabaseService
    
    Returns:
    a new transaction instance
  - beginTx
```
protected Transaction beginTx(org.neo4j.kernel.impl.transaction.xaframework.ForceMode forceMode)
```
  - transactionRunning
```
public boolean transactionRunning()
```
    Specified by:
    
    transactionRunning in class AbstractGraphDatabase
  - isEphemeral
```
protected boolean isEphemeral()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getAllNodes
```
public Iterable<Node> getAllNodes()
```
    Description copied from interface: GraphDatabaseService
    
    Returns all nodes in the graph.
    
    Specified by:
    
    getAllNodes in interface GraphDatabaseService
    
    Returns:
    all nodes in the graph.
  - getRelationshipTypes
```
public Iterable<RelationshipType> getRelationshipTypes()
```
    Description copied from interface: GraphDatabaseService
    
    Returns all relationship types currently in the underlying store. Relationship types are added to the underlying store the first time they are used in a successfully commited node.createRelationshipTo(...). Note that this method is guaranteed to return all known relationship types, but it does not guarantee that it won't return more than that (e.g. it can return "historic" relationship types that no longer have any relationships in the node space).
    
    Specified by:
    
    getRelationshipTypes in interface GraphDatabaseService
    
    Returns:
    all relationship types in the underlying store
  - registerKernelEventHandler
```
public KernelEventHandler registerKernelEventHandler(KernelEventHandler handler)
```
    Description copied from interface: GraphDatabaseService
    
    Registers handler as a handler for kernel events which are generated from different places in the lifecycle of the kernel. To guarantee proper behaviour the handler should be registered right after the graph database has been started. If the specified handler instance has already been registered this method will do nothing.
    
    Specified by:
    
    registerKernelEventHandler in interface GraphDatabaseService
    
    Parameters:
    handler - the handler to receive events about different states in the kernel lifecycle.
    
    Returns:
    the handler passed in as the argument.
  - registerTransactionEventHandler
```
public <T> TransactionEventHandler<T> registerTransactionEventHandler(TransactionEventHandler<T> handler)
```
    Description copied from interface: GraphDatabaseService
    
    Registers handler as a handler for transaction events which are generated from different places in the lifecycle of each transaction. To guarantee that the handler gets all events properly it shouldn't be registered when the application is running (i.e. in the middle of one or more transactions). If the specified handler instance has already been registered this method will do nothing.
    
    Specified by:
    
    registerTransactionEventHandler in interface GraphDatabaseService
    
    Type Parameters:
    T - the type of state object used in the handler, see more documentation about it at TransactionEventHandler.
    Parameters:
    handler - the handler to receive events about different states in transaction lifecycles.
    
    Returns:
    the handler passed in as the argument.
  - unregisterKernelEventHandler
```
public KernelEventHandler unregisterKernelEventHandler(KernelEventHandler handler)
```
    Description copied from interface: GraphDatabaseService
    
    Unregisters handler from the list of kernel event handlers. If handler hasn't been registered with GraphDatabaseService.registerKernelEventHandler(KernelEventHandler) prior to calling this method an IllegalStateException will be thrown. After a successful call to this method the handler will no longer receive any kernel events.
    
    Specified by:
    
    unregisterKernelEventHandler in interface GraphDatabaseService
    
    Parameters:
    handler - the handler to receive events about different states in the kernel lifecycle.
    
    Returns:
    the handler passed in as the argument.
  - unregisterTransactionEventHandler
```
public <T> TransactionEventHandler<T> unregisterTransactionEventHandler(TransactionEventHandler<T> handler)
```
    Description copied from interface: GraphDatabaseService
    
    Unregisters handler from the list of transaction event handlers. If handler hasn't been registered with GraphDatabaseService.registerTransactionEventHandler(TransactionEventHandler) prior to calling this method an IllegalStateException will be thrown. After a successful call to this method the handler will no longer receive any transaction events.
    
    Specified by:
    
    unregisterTransactionEventHandler in interface GraphDatabaseService
    
    Type Parameters:
    T - the type of state object used in the handler, see more documentation about it at TransactionEventHandler.
    Parameters:
    handler - the handler to receive events about different states in transaction lifecycles.
    
    Returns:
    the handler passed in as the argument.
  - createNode
```
public Node createNode()
```
    Description copied from interface: GraphDatabaseService
    
    Creates a new node.
    
    Specified by:
    
    createNode in interface GraphDatabaseService
    
    Returns:
    the created node.
  - createNode
```
public Node createNode(Label... labels)
```
    Description copied from interface: GraphDatabaseService
    
    Creates a new node and adds the provided labels to it.
    
    Specified by:
    
    createNode in interface GraphDatabaseService
    
    Parameters:
    labels - labels to add to the created node.
    
    Returns:
    the created node.
  - getNodeById
```
public Node getNodeById(long id)
```
    Description copied from interface: GraphDatabaseService
    
    Looks up a node by id. Please note: Neo4j reuses its internal ids when nodes and relationships are deleted, which means it's bad practice to refer to them this way. Instead, use application generated ids.
    
    Specified by:
    
    getNodeById in interface GraphDatabaseService
    
    Parameters:
    id - the id of the node
    
    Returns:
    the node with id id if found
  - getRelationshipById
```
public Relationship getRelationshipById(long id)
```
    Description copied from interface: GraphDatabaseService
    
    Looks up a relationship by id. Please note: Neo4j reuses its internal ids when nodes and relationships are deleted, which means it's bad practice to refer to them this way. Instead, use application generated ids.
    
    Specified by:
    
    getRelationshipById in interface GraphDatabaseService
    
    Parameters:
    id - the id of the relationship
    
    Returns:
    the relationship with id id if found
  - getReferenceNode
```
public Node getReferenceNode()
```
    Description copied from interface: GraphDatabaseService
    
    Returns the reference node, which is a "starting point" in the node space. Usually, a client attaches relationships to this node that leads into various parts of the graph.
    
    Specified by:
    
    getReferenceNode in interface GraphDatabaseService
    
    Returns:
    the reference node
  - tx
```
public TransactionBuilder tx()
```
    Specified by:
    
    tx in interface GraphDatabaseAPI
  - getGuard
```
public Guard getGuard()
```
    Specified by:
    
    getGuard in interface GraphDatabaseAPI
  - getKernelData
```
public KernelData getKernelData()
```
    Specified by:
    
    getKernelData in interface GraphDatabaseAPI
  - index
```
public IndexManager index()
```
    Description copied from interface: GraphDatabaseService
    
    Returns the IndexManager paired with this graph database service and is the entry point for managing indexes coupled with this database.
    
    Specified by:
    
    index in interface GraphDatabaseService
    
    Returns:
    the IndexManager for this database.
  - schema
```
public Schema schema()
```
    Description copied from interface: GraphDatabaseService
    
    Returns the schema manager where all things related to schema, for example constraints and indexing on labels.
    
    Specified by:
    
    schema in interface GraphDatabaseService
    
    Returns:
    the schema manager for this database.
  - getConfig
```
public Config getConfig()
```
  - getNodeManager
```
public org.neo4j.kernel.impl.core.NodeManager getNodeManager()
```
    Specified by:
    
    getNodeManager in interface GraphDatabaseAPI
  - getLockManager
```
public org.neo4j.kernel.impl.transaction.LockManager getLockManager()
```
    Specified by:
    
    getLockManager in interface GraphDatabaseAPI
  - getXaDataSourceManager
```
public org.neo4j.kernel.impl.transaction.XaDataSourceManager getXaDataSourceManager()
```
    Specified by:
    
    getXaDataSourceManager in interface GraphDatabaseAPI
  - getTxManager
```
public TransactionManager getTxManager()
```
    Specified by:
    
    getTxManager in interface GraphDatabaseAPI
  - getRelationshipTypeTokenHolder
```
public org.neo4j.kernel.impl.core.RelationshipTypeTokenHolder getRelationshipTypeTokenHolder()
```
    Specified by:
    
    getRelationshipTypeTokenHolder in interface GraphDatabaseAPI
  - getIdGeneratorFactory
```
public IdGeneratorFactory getIdGeneratorFactory()
```
    Specified by:
    
    getIdGeneratorFactory in interface GraphDatabaseAPI
  - getDiagnosticsManager
```
public DiagnosticsManager getDiagnosticsManager()
```
    Specified by:
    
    getDiagnosticsManager in interface GraphDatabaseAPI
  - getPersistenceSource
```
public org.neo4j.kernel.impl.persistence.PersistenceSource getPersistenceSource()
```
    Specified by:
    
    getPersistenceSource in interface GraphDatabaseAPI
  - getMessageLog
```
public final org.neo4j.kernel.impl.util.StringLogger getMessageLog()
```
    Specified by:
    
    getMessageLog in interface GraphDatabaseAPI
  - getTxIdGenerator
```
public org.neo4j.kernel.impl.transaction.xaframework.TxIdGenerator getTxIdGenerator()
```
    Specified by:
    
    getTxIdGenerator in interface GraphDatabaseAPI
  - getKernelPanicGenerator
```
public org.neo4j.kernel.impl.core.KernelPanicEventGenerator getKernelPanicGenerator()
```
    Specified by:
    
    getKernelPanicGenerator in interface GraphDatabaseAPI
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - findNodesByLabelAndProperty
```
public ResourceIterable<Node> findNodesByLabelAndProperty(Label myLabel,
                                                 String key,
                                                 Object value)
```
    Description copied from interface: GraphDatabaseService
    
    Returns all nodes having the label, and the wanted property value. If an online index is found, it will be used to look up the requested nodes.
    If no indexes exist for the label/property combination, the database will scan all labelled nodes looking for the property value. If you call this operation outside of a transaction, please take care that the returned ResourceIterable is closed correctly to avoid potential blocking of write operations.
    
    Specified by:
    
    findNodesByLabelAndProperty in interface GraphDatabaseService
    
    Parameters:
    myLabel - consider nodes with this label
    key - required property key
    value - required property value
    
    Returns:
    an iterable containing all matching nodes. See { @link ResourceIterable } for responsibilities.

Class InternalAbstractGraphDatabase

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

storeDir

params

storeId

config

dependencyResolver

logging

msgLog

storeLocker

kernelEventHandlers

transactionEventHandlers

relationshipTypeTokenHolder

nodeManager

indexManager

schema

kernelPanicEventGenerator

txHook

fileSystem

xaDataSourceManager

lockManager

idGeneratorFactory

relationshipTypeCreator

persistenceSource

syncHook

persistenceManager

propertyKeyTokenHolder

labelTokenHolder

indexStore

logBufferFactory

txManager

txIdGenerator

storeFactory

xaFactory

diagnosticsManager

neoDataSource

recoveryVerifier

guard

nodeAutoIndexer

relAutoIndexer

extensions

caches

stateFactory

kernelAPI

statementContextProvider

cacheBridge

jobScheduler

updateableSchemaState

cleanupService

life

Constructor Detail

InternalAbstractGraphDatabase

Method Detail

run

registerRecovery

doAfterRecoveryAndStartup

create

isHighlyAvailable

createCleanupService

createTransactionStateFactory

createXaDataSourceManager

getDependencyResolver

createRelationshipTypeCreator

createPropertyKeyCreator

createLabelIdCreator

shutdown

createStoreFactory

createRecoveryVerifier

createKernelData

createTxIdGenerator

createCaches

createRelationshipLookups

createNodeLookup

createTxHook

createFileSystemAbstraction