java.lang.Object
- org.neo4j.graphalgo.core.huge.HugeGraph

All Implemented Interfaces:

BatchNodeIterable, Degrees, Graph, IdMapping, NodeIterator, NodeMapping, NodePropertyContainer, RelationshipAccess, RelationshipIterator, RelationshipPredicate, RelationshipProperties
```
public class HugeGraph
extends java.lang.Object
implements Graph
```
Huge Graph contains two array like data structures.
The adjacency data is stored in a ByteArray, which is a byte[] addressable by longs indices and capable of storing about 2^46 (~ 70k bn) bytes – or 64 TiB. The bytes are stored in byte[] pages of 32 KiB size.
The data is in the format:
degree ~ targetId₁ ~ targetId₂ ~ targetId_n
The degree is stored as a fill-sized 4 byte long int (the neo kernel api returns an int for Nodes.countAll(org.neo4j.internal.kernel.api.NodeCursor, org.neo4j.internal.kernel.api.CursorFactory)). Every target ID is first sorted, then delta encoded, and finally written as variable-length vlongs. The delta encoding does not write the actual value but only the difference to the previous value, which plays very nice with the vlong encoding.
The seconds data structure is a LongArray, which is a long[] addressable by longs and capable of storing about 2^43 (~9k bn) longs – or 64 TiB worth of 64 bit longs. The data is the offset address into the aforementioned adjacency array, the index is the respective source node id.
To traverse all nodes, first access to offset from the LongArray, then read 4 bytes into the degree from the ByteArray, starting from the offset, then read degree vlongs as targetId.
Reading the degree from the offset position not only does not require the offset array to be sorted but also allows the adjacency array to be sparse. This fact is used during the import – each thread pre-allocates a local chunk of some pages (512 KiB) and gives access to this data during import. Synchronization between threads only has to happen when a new chunk has to be pre-allocated. This is similar to what most garbage collectors do with TLAB allocations.

See Also:

more abount vlong, more abount TLAB allocation

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`HugeGraph.GetTargetConsumer`
`static interface`	`HugeGraph.PropertyCSR`
`static interface`	`HugeGraph.Relationships`
`static interface`	`HugeGraph.TopologyCSR`

Field Summary

Fields
Modifier and Type Field Description

static double NO_PROPERTY_VALUE
- Fields inherited from interface org.neo4j.graphalgo.api.IdMapping
  START_NODE_ID

Constructor Summary

Constructors
Constructor	Description
`HugeGraph(IdMap idMapping, java.util.Map<java.lang.String,NodeProperties> nodeProperties, long relationshipCount, AdjacencyList adjacencyList, AdjacencyOffsets adjacencyOffsets, boolean hasRelationshipProperty, double defaultPropertyValue, @Nullable AdjacencyList properties, @Nullable AdjacencyOffsets propertyOffsets, Orientation orientation, AllocationTracker tracker)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`java.util.Set<java.lang.String>`	`availableNodeProperties()`
`java.util.Collection<PrimitiveLongIterable>`	`batchIterables(int batchSize)`
`void`	`canRelease(boolean canRelease)`
`HugeGraph`	`concurrentCopy()`
`boolean`	`contains(long nodeId)`	Returns true iff the nodeId is mapped, otherwise false.
`static HugeGraph`	`create(IdMap nodes, java.util.Map<java.lang.String,NodeProperties> nodeProperties, HugeGraph.TopologyCSR topologyCSR, java.util.Optional<HugeGraph.PropertyCSR> maybePropertyCSR, AllocationTracker tracker)`
`int`	`degree(long node)`
`boolean`	`exists(long sourceNodeId, long targetNodeId)`	O(n) !
`void`	`forEachNode(java.util.function.LongPredicate consumer)`	Iterate over each nodeId
`void`	`forEachRelationship(long nodeId, double fallbackValue, RelationshipWithPropertyConsumer consumer)`	Calls the given consumer function for every relationship of a given node.
`void`	`forEachRelationship(long nodeId, RelationshipConsumer consumer)`	Calls the given consumer function for every relationship of a given node.
`long`	`getTarget(long sourceNodeId, long index)`
`boolean`	`hasRelationshipProperty()`
`IdMap`	`idMap()`
`RelationshipIntersect`	`intersection(long maxDegree)`
`boolean`	`isUndirected()`
`long`	`nodeCount()`	Number of mapped nodeIds.
`PrimitiveLongIterator`	`nodeIterator()`
`NodeMapping`	`nodeMapping()`
`NodeProperties`	`nodeProperties(java.lang.String propertyKey)`	Return the property values for a property key
`Orientation`	`orientation()`
`long`	`relationshipCount()`
`double`	`relationshipProperty(long sourceNodeId, long targetNodeId)`	Returns the property value for a relationship defined by its source and target nodes.
`double`	`relationshipProperty(long sourceId, long targetId, double fallbackValue)`	get value of property on relationship between source and target node id
`HugeGraph.Relationships`	`relationships()`
`void`	`releaseProperties()`	Release only the properties associated with that graph.
`void`	`releaseTopology()`	Release only the topological data associated with that graph.
`long`	`toMappedNodeId(long nodeId)`	Map original nodeId to inner nodeId
`long`	`toOriginalNodeId(long nodeId)`	Map inner nodeId back to original nodeId

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

Methods inherited from interface org.neo4j.graphalgo.api.Graph
availableNodeLabels, intersection, isEmpty, nodeLabels, release

Methods inherited from interface org.neo4j.graphalgo.api.NodeMapping
containsOnlyAllNodesLabel, hasLabel

- Field Detail
  - NO_PROPERTY_VALUE
```
public static final double NO_PROPERTY_VALUE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - HugeGraph
```
public HugeGraph(IdMap idMapping,
                 java.util.Map<java.lang.String,NodeProperties> nodeProperties,
                 long relationshipCount,
                 AdjacencyList adjacencyList,
                 AdjacencyOffsets adjacencyOffsets,
                 boolean hasRelationshipProperty,
                 double defaultPropertyValue,
                 @Nullable
                 @Nullable AdjacencyList properties,
                 @Nullable
                 @Nullable AdjacencyOffsets propertyOffsets,
                 Orientation orientation,
                 AllocationTracker tracker)
```
- Method Detail
  - create
```
public static HugeGraph create(IdMap nodes,
                               java.util.Map<java.lang.String,NodeProperties> nodeProperties,
                               HugeGraph.TopologyCSR topologyCSR,
                               java.util.Optional<HugeGraph.PropertyCSR> maybePropertyCSR,
                               AllocationTracker tracker)
```
  - nodeCount
```
public long nodeCount()
```
    Description copied from interface: IdMapping
    
    Number of mapped nodeIds.
    
    Specified by:
    
    nodeCount in interface IdMapping
  - idMap
```
public IdMap idMap()
```
  - nodeMapping
```
public NodeMapping nodeMapping()
```
    Specified by:
    
    nodeMapping in interface Graph
  - relationshipCount
```
public long relationshipCount()
```
    Specified by:
    
    relationshipCount in interface Graph
    
    Returns:
    
    returns the total number of relationships in the graph.
  - batchIterables
```
public java.util.Collection<PrimitiveLongIterable> batchIterables(int batchSize)
```
    Specified by:
    
    batchIterables in interface BatchNodeIterable
    
    Returns:
    
    a collection of iterables over every node, partitioned by the given batch size.
  - forEachNode
```
public void forEachNode(java.util.function.LongPredicate consumer)
```
    Description copied from interface: NodeIterator
    
    Iterate over each nodeId
    
    Specified by:
    
    forEachNode in interface NodeIterator
  - nodeIterator
```
public PrimitiveLongIterator nodeIterator()
```
    Specified by:
    
    nodeIterator in interface NodeIterator
  - relationshipProperty
```
public double relationshipProperty(long sourceNodeId,
                                   long targetNodeId)
```
    Description copied from interface: RelationshipProperties
    
    Returns the property value for a relationship defined by its source and target nodes.
    
    Specified by:
    
    relationshipProperty in interface RelationshipProperties
  - relationshipProperty
```
public double relationshipProperty(long sourceId,
                                   long targetId,
                                   double fallbackValue)
```
    Description copied from interface: RelationshipProperties
    
    get value of property on relationship between source and target node id
    
    Specified by:
    
    relationshipProperty in interface RelationshipProperties
    
    Parameters:
    
    sourceId - source node
    
    targetId - target node
    
    fallbackValue - value to use if relationship has no property value
    
    Returns:
    
    the property value
  - nodeProperties
```
public NodeProperties nodeProperties(java.lang.String propertyKey)
```
    Description copied from interface: NodePropertyContainer
    
    Return the property values for a property key
    
    Specified by:
    
    nodeProperties in interface NodePropertyContainer
    
    Parameters:
    
    propertyKey - the node property key
    
    Returns:
    
    the values associated with that key
  - availableNodeProperties
```
public java.util.Set<java.lang.String> availableNodeProperties()
```
    Specified by:
    
    availableNodeProperties in interface NodePropertyContainer
  - forEachRelationship
```
public void forEachRelationship(long nodeId,
                                RelationshipConsumer consumer)
```
    Description copied from interface: RelationshipIterator
    
    Calls the given consumer function for every relationship of a given node.
    
    Specified by:
    
    forEachRelationship in interface RelationshipIterator
    
    Parameters:
    
    nodeId - id of the node for which to iterate relationships
    
    consumer - relationship consumer function
  - forEachRelationship
```
public void forEachRelationship(long nodeId,
                                double fallbackValue,
                                RelationshipWithPropertyConsumer consumer)
```
    Description copied from interface: RelationshipIterator
    
    Calls the given consumer function for every relationship of a given node. If the graph was loaded with a relationship property, the property value of the relationship will be passed into the consumer. Otherwise the given fallback value will be used.
    
    Specified by:
    
    forEachRelationship in interface RelationshipIterator
    
    Parameters:
    
    nodeId - id of the node for which to iterate relationships
    
    fallbackValue - value used as relationship property if no properties were loaded
    
    consumer - relationship consumer function
  - degree
```
public int degree(long node)
```
    Specified by:
    
    degree in interface Degrees
  - toMappedNodeId
```
public long toMappedNodeId(long nodeId)
```
    Description copied from interface: IdMapping
    
    Map original nodeId to inner nodeId
    
    Specified by:
    
    toMappedNodeId in interface IdMapping
  - toOriginalNodeId
```
public long toOriginalNodeId(long nodeId)
```
    Description copied from interface: IdMapping
    
    Map inner nodeId back to original nodeId
    
    Specified by:
    
    toOriginalNodeId in interface IdMapping
  - contains
```
public boolean contains(long nodeId)
```
    Description copied from interface: IdMapping
    
    Returns true iff the nodeId is mapped, otherwise false.
    
    Specified by:
    
    contains in interface IdMapping
  - concurrentCopy
```
public HugeGraph concurrentCopy()
```
    Specified by:
    
    concurrentCopy in interface Graph
    
    Specified by:
    
    concurrentCopy in interface RelationshipIterator
    
    Returns:
    
    a copy of this iterator that reuses new cursors internally, so that iterations happen independent from other iterations.
  - intersection
```
public RelationshipIntersect intersection(long maxDegree)
```
    Specified by:
    
    intersection in interface Graph
  - exists
```
public boolean exists(long sourceNodeId,
                      long targetNodeId)
```
    O(n) !
    
    Specified by:
    
    exists in interface RelationshipPredicate
  - getTarget
```
public long getTarget(long sourceNodeId,
                      long index)
```
    Specified by:
    
    getTarget in interface RelationshipAccess
  - canRelease
```
public void canRelease(boolean canRelease)
```
    Specified by:
    
    canRelease in interface Graph
  - releaseTopology
```
public void releaseTopology()
```
    Description copied from interface: Graph
    
    Release only the topological data associated with that graph.
    
    Specified by:
    
    releaseTopology in interface Graph
  - releaseProperties
```
public void releaseProperties()
```
    Description copied from interface: Graph
    
    Release only the properties associated with that graph.
    
    Specified by:
    
    releaseProperties in interface Graph
  - isUndirected
```
public boolean isUndirected()
```
    Specified by:
    
    isUndirected in interface Graph
  - orientation
```
public Orientation orientation()
```
  - relationships
```
public HugeGraph.Relationships relationships()
```
  - hasRelationshipProperty
```
public boolean hasRelationshipProperty()
```
    Specified by:
    
    hasRelationshipProperty in interface Graph

Class HugeGraph

Nested Class Summary

Field Summary

Fields inherited from interface org.neo4j.graphalgo.api.IdMapping

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.neo4j.graphalgo.api.Graph

Methods inherited from interface org.neo4j.graphalgo.api.NodeMapping

Field Detail

NO_PROPERTY_VALUE

Constructor Detail

HugeGraph

Method Detail

create

nodeCount

idMap

nodeMapping

relationshipCount

batchIterables

forEachNode

nodeIterator

relationshipProperty

relationshipProperty

nodeProperties

availableNodeProperties

forEachRelationship

forEachRelationship

degree

toMappedNodeId

toOriginalNodeId

contains

concurrentCopy

intersection

exists

getTarget

canRelease

releaseTopology

releaseProperties

isUndirected

orientation

relationships

hasRelationshipProperty