store files in Neo4j : neostore.nodestore.db - neo4j

I'm reading about Neo4j underlying infrastructure in it's book and I think I found a contradiction .Here In the text it is mentioned that :"The next four
bytes represent the ID of the first relationship connected to the node, and the following
four bytes represent the ID of the first property for the node" :
but as you can see in the figure 6-4 : if you look at the photo it is Nextrelid! which one is correct? and if we only store first relationship in the nodestore file, what happen to the other relationship?

From the point of view of the node, the next relationship id is the same thing as "the id of the first relationship connected to the node". They're different ways of describing the same thing.
The pattern here is that relationships are stored as a chain. To iterate over all relationships, from the node, you use the id of the first relationship to jump to that relationship in memory, then jump to the area in memory on that relationship where the next rel id is stored and pointer chase across the rest of the chain.
That said, when relationships reach a particular density (I think it's 50 rels per node) then the structure is somewhat different, a new entity is present between the node and its relationships to allow for more efficient navigation of its relationships.

Related

How to make a 'blueprint' of all possible relationships and nodes in Neo4J with Cypher?

What I want to create is a blueprint of my datamodel.
What I mean with blueprint is a newly created datamodel, where every node is created only once; every node with a unique label (with eiter none, one or multiple labels) from my real database must be copied and shown once.
For every unique node in this blueprint, I also need a relationship blueprint. So for every different relationship (either by name, direction or connected nodes) I also need only one representation.
Example: Say i have have 4 nodes, of which 2 are Persons and 2 are Companies; then in the blueprint only 2 nodes are shown. These are the relationships:
(c)-[:LIKES]->(p)
(c)-[:LIKES]->(p)
(c)-[:LIKES]->(c)
(c)-[:LIKES]->(c)
(p)<-[DISLIKS]-(c)
These relationships show 3 unique relationships, based on name, direction and nodes connected.
So for this blueprint, the outcome must be 2 unique nodes with 3 unique relationships.
I've been struggling with the code to realize this for a while.
Any suggestions much appreciated!
It seems the Neo4j built-in procedure db.schema.visualization() is what you're looking for : https://neo4j.com/docs/operations-manual/current/reference/procedures/#procedure_db_schema_visualization
Example :

How does Neo4j Traverse a graph using relationship ID's in nodestore file

Something has confused me a lot I was Wondering If you could help me with this please
According to Neo4j graph database book, there are 4 bytes in node store file contains the ID of the nodes relationship . If the node has 100 relationship (and all of them are the node's first relationship in the relationship chain) how does neo4j understand which id to choose??? for example I wrote Match(a:user{Name:'a')-[r:Has-skill]->(b:skill)
Imagine The user node has lot's of relationship but we are interested in [has_skill] relationship how does neo4j understand which id in related to this relationship?
The relationship chain that you are talking about is not the same as a "path". A node does not have more than one relationship that is the first in the chain.
The chain of relationships is a doubly-linked list that contains that Node's relationships. Given that Neo4J already has found the first user in the pattern, it will perform the following steps (or something similar):
Follow the pointer from the node record to the first element of the linked list that contains all of that node's relationships (this first element is the "first relationship in the chain").
For each element of the linked list:
Check if matches the criteria for the searched-for relationship (here, it would be that it has the type HAS_SKILL).
If it does match the criteria, the relationship is kept for future following; if it does not match, it is discarded.
Follow the pointer to the next element in the relationship linked-list (in the "chain"); if at the last element already, exit the loop.
For each of the relationships retrieved by scanning the linked list, follow them to the node they point to and continue evaluating the pattern.
The actual algorithm may differ slightly; e.g. it may use depth-first traversal instead of breadth-first, or it may be optimized in a different way, but the end result is the same.
From Graph Databases, 2nd Edition by Ian Robinson, Jim Webber and Emil Eifrem, page 154:
To find a relationship for a node, we follow that node’s relationship pointer to its first relationship (the LIKES relation‐ ship in this example). From here, we then follow the doubly linked list of relation‐ ships for that particular node (that is, either the start node doubly linked list, or the end node doubly linked list) until we find the relationship we’re interested in.
Finally, #InverseFalcon points out that this will be implemented differently for densely-related nodes, by their estimate at around 50+ relationships. At this point, a slightly different structure is used which groups by types and direction so the cost to search through is reduced.

how new traverse api works

nowadaya i m learning new traverse api of neo4j and i followed the link below
http://neo4j.com/docs/stable/tutorial-traversal-java-api.html
so now i know how to use uniqueness,evaluater etc.
that is i know how to change beahviours of the api.
but the thing i want to know is that how exactly it traverse.
for example im trying to find neighbours of a node.
does neo4j use index to find this?
does neo4j keep a hash to find neighbours?
more specifically, when i write the following code for example.
TraversalDescription desc = database.traversalDescription().breadthFirst().evaluator( Evaluators.toDepth( 3) );
node =database.getNodeById(4601410);
Traverser traverser = desc.traverse(node);
in my description i used breadthFirst. So it means that when i give node to traverse, the code should find the first neighbours. So how the api finds the first neighbours is the thing i want to know. Is there a pointer to neighbours in node? So when i say traverse until to depth 3 it finds the first neighbours and then take the neighbours as node in a recursive function and so on? So if we say to depth 10 then it can be slow?
so what i want exactly is how i can change the natural behaviour of the api to traverse?
Simplified, Neo4j stores records representing nodes and relationships a.s.o. in its store. Every node is represented by a node record on disk, that record contains a pointer (direct offset into relationship store) for the first relationship (neighbour if you will). Relationship records link to each other, so getting all neighbours for a node will read the node record, its relationship pointer to that relationship record and continue following those forward pointers until the end of that chain. Does that answer your question?
TraversalDescription features a concept of PathExpander - that is the component deciding which relationships will be used for the next step. Use TraversalDescription.expand() for this.
You can either use your own implementation for PathExpander or use one of the predefined methods in PathExpanders.
If you just want your traversal follow specific relationship types you can use TraversalDescription.relationships() to specify those.

Assumptions regarding Node ID strings in Neo4j - cypher

In my recent question, Modeling conditional relationships in neo4j v.2 (cypher), the answer has led me to another question regarding my data model and the cypher syntax to represent it. Lets say in my model, there is a node CLT1 that is what I'll call the Source node. CLT1 has relationships to other 286 Target nodes. This is a model of a target node:
CREATE
(Abnormally_high:Label1:Label2:Label3:Label4:Label5:Label6:Label7:Label8:Label9:Label10
{Pro1:'x',Prop2:'y',Prop3:'z'})
Key point: I am assuming the string after the CREATE clause is
The ID of this target node
The ID is significant because its content has domain-specific meaning
and is query-able.
in this case its the phrase ...."Abnormally_high".
I made this assumption based on the movie database example.
CREATE (Keanu:Person {name:'Keanu Reeves', born:1964})
CREATE (Carrie:Person {name:'Carrie-Anne Moss', born:1967})
The first strings after CREATE definitely have domain-specific meaning!
In my earlier post I discuss Problem 2. I find that problem 2 arises because among the 286 target nodes, there are many instances where there was at least one more Target node who shares the identical ID. In this instance, the ID is "Abnormally_high". The other Target nodes may differ in the value of any of Label1 - Label10 or the associated properties.
Apparently, Cypher doesn't like that. In Problem 2, I was discussing the ways to deal with the fact that cypher doesn't like using the same node ID multiple times even though the labels or properties were different.
My problem are my assumptions about the Target node ID.
AM I RIGHT?
I am now thinking that I could instead use this....
CREATE (CLT1_target_1:Label1:Label2:Label3:Label4:Label5:Label6:Label7:Label8:Label9:Label10
{name:'Abnormally_high',Prop2:'y',Prop3:'z'})
If indeed the first string after the CREATE clause is an ID, then all I have to do is put a unique target node identifier.... like CLT1_target_1 and increment up to CLT1_target_286. If I do this, then I can have the name as a property and change whatever label or property I want.
Do I have this right?
You are wrong. In Cypher, a node name (like "Abnormally_high") is just a variable name that exists for the lifetime of the query (and sometimes not even that long). The node name used in a Cypher query is never persisted in any way, and can be any arbitrary string.
Also, in neo4j, the term "ID" has a specific meaning. The neo4j DB will automatically assign a (currently) unique integer ID to each new node. You have no control over the ID value assigned to a node. And when a node is deleted, neo4j can reassign its ID to a new node.
You should read the neo4j manual (available at docs.neo4j.org), especially the section on Cypher, to get a better understanding.

Category design in Neo4j, root node relationships vs relationships to indexed nodes

I would like to represent millions of products that belong to one or more of dozens of categories.
I'm contemplating a few approaches:
Indexed Category Nodes - Create nodes for each category and create an auto_index on category_name. Then create "isCategoryOf" relationships between each of my product nodes and their respective category nodes.
Individual Category Relationship Types- Create respective "isCategoryGames", "isCategoryFood", "isCategoryLifestyle", etc... relationships between products and the root node.
Storing Categories as a Property of One Relationship Type - Create "isCategory" relationshps between prduct nodes and the root node and store their respective category types in a property of the relationship, e.g. relationship "isCategory" { categoryName:"food"}
Which of these approaches is most efficent and/or scalable. Is there a limit or performance implications of having almost every node in the database connect to the root node?
If you attach millions of nodes to the root node, you make the root node a supernode. This can be problematic.
The general concept of Option 1 shows promise. If you were modeling food, you might have nodes with a name property like "Nuts", "Dairy Products", "Desserts", "Produce" and a type property of "Category". You would then have other nodes with a name property like "Cherry Cheesecake" with outgoing "category" edges to the "Dairy Products", and "Desserts" nodes.
Whether this structure is going to be performant enough depends on your queries. If you have broad categories like 'food', you could end up with a supernode, and you'll take a linear scan through the connected nodes to find a node with a given property. A linear scan over thousands of things might be fast enough for your purposes, but a scan over 1M things might not.
To find out, I would recommend creating a quick prototype where you generate some random product and category nodes, then connect each product node to a random number of category nodes. Indexing the product and category nodes by name will help you find individual products or categories, but it's the traversals that will cause performance problems if you hit supernodes. Experiment with a few of the Gremlin traversals or Cypher queries that you think might be most problematic. Try scaling up the number of nodes from 1K, 10K, 100K, and 1M with a proportionate number of edges. How do your traversal / query times change?

Resources