Neo4j using the Cypher language
Cypher language is the use of database operation language (DML) when learning neo4j, including the deletion and modification of graph data
The concept of neo4j database simple and violent comprehension:
There is no concept of table in neo4j, there are only two types: node and association (Relation), which can be easily understood as the points and edges inside the graph.
In a data query, a node is usually enclosed in parentheses (), with brackets [].
Of course, the concept of implicit paths is represented by nodes and associations, such as: (a)-[r]-> (b), which represents a path from Node A through association R to Node B.
To back up neo4j data:
1 ) to stop the database. 2) Backup D:\Neo4J\neo4j-Enterprise-1.9. 1 all content in the Graph.db directory under the \data directory. 3) Copy the contents of the Graph.db directory on the server to the same directory as the new server and start.
Basic operation of Cypher
1) Create a node
Create ( a) creates an empty node create ( A:person) creates a label (which can be understood as a class) for the person's node create (A:person {name: ' Kaine ', Age: 28}) Create a node with a label of person, a property name value of Kaine, and a property with an age value of 28
2) Create an association
Match (a), (b) where a.name= ' Kaine ' and b.name=' Sharon ' create (a)-[r]-> (b) Creates a path to A and B nodes, at which time the variable r represents the association, and it can have a label
3) Query Keywords
Match : matches a certain pattern, which can be a simple node, an association, or a complex path where: To qualify a condition, it is generally a property of the variable that qualifies the match in return : Returns the result start : Start node, typically used for indexed nodes or associations
return ... If match has multiple objects separated by commas, if where has multiple conditions, connect with and, if return has more than one variable, separated by commas
4) Query Examples
match (N) return n
Query all nodes and associated match (a) -[r]-> (b) where a.name= ' Kaine ' return b
The value of the query property name is Kaine node, and all its associated nodes match (a) -[*1..3]-> (b) where a.name= ' Kaine ' return b
the query property name value is a node of Kaine and all associated nodes with a distance of 1 to 3, match (a) - [*2]-> (b) where a.name= ' Kaine ' and not (a)-[*1]-> (b) return A, b
The value of the query property name is the node for Kaine, and all of its distances are 2 and the node with the distance of 1 is removed.
(used when calculating a friend's friend, that is, if a, B, c three people know, if only to calculate with a distance of 2 people will also count B, C, because A->b->c, or A->c->b are all pathways) Note: The meaning of the number within the associative brackets is n. n the maximum distance is n N. The minimum distance is N m. n distance between M to n
A. Create
CREATE (Id:label {key:value})
ID: Add a unique ID for the node, do not set the system to set one automatically, not set when the CREATE (: Label ...
Label: tag, life node type
{}: property definition, key/value format
B. Relationship
-[role:label {roles: ["Neo"]}]->-- represents a non-pointing relationship--Indicates a directed relationship [] can add ID, attribute, type, etc. information
See also: http://blog.csdn.net/wangweislk/article/details/47661863
Query by ID (the ID here is automatically created by the system): Start n=Node -)returnm; query all nodes: Start n=Node*)returnN; Query properties, Relationship: Start n=Node9)returnN,n.name,n.id,n. Level;//View the specified node, return the required properties start n=Node*) match (N)-[r:subclassof] -MreturnM,n,n.name,n.id,r;//find a specified relationship query multiple nodes by relationship: Start a=Node -) Match B-[R]<->AreturnR,b;start a=Node0) Match C-[: KNOWS] -B-[: KNOWS] -AreturnA,b,c;//find node for two-tier knows relationship start a=Node +) Match B-[*] -Areturnb;//find all nodes that are related to a node use the Where condition to query: (You can use it without establishing index) start n=Node*)whereN.name="Activity"returnN; and can use a specific symbol: Start n=Node*)whereN.id?="A*"returnN; start n=Node*)whereHas (N.type)returnN,n.name,n.id,n.type;//If a property type exists and starts with a, the node is output. The configuration file is automatically indexed: Modify the contents of the Neo4j.properties file in the Conf directory as follows, restart the neo4j and take effect on the new node after the restart. # Enable Auto-Indexing forNodesdefault isfalsenode_auto_indexing=true# the Node property keys toBe auto-Indexedifenablednode_keys_indexable=name,id# Enable Auto-Indexing forRelationships,default isfalserelationship_auto_indexing=true# The Relationship property keys toBe auto-Indexedifenabledrelationship_keys_indexable=knows,subclassof can be queried with Node_auto_index by attribute value after indexing: Start n=Node:node_auto_index (name="C")returnN,n.name; Modify a property value: Start a=Node*)whereA.name=ASetA.name=Areturna,a.name; start n=Node0)SetN.name="Root", n.id="001" ;//Add the Name,id property to the default root node for easy querying. Delete: Delete all nodes and relationships: START n=Node*) match n-[R]-()DeleteN,r;
Delete all nodes The above method is obsolete, the later version will be abandoned-the following method is recommended
MATCH (N)
OPTIONAL MATCH (n)-[r]-()
DELETE N,r
Graphical Database relationships
A concept
Node:
(a)//actors (m)//movies ()//some anonymous nod
Relationship:
-[r]->//a relationship referred to as "R" (a)-[r]-> (m)//actors have a relationship referred to as "R" to movies-[ :acted_in]->//the Relationship type is acted_in (a)-[:acted_in]-> (m)//actors that acted_in some movie (d)-[:D Irected]-> (m)//directors that DIRECTED some movie
Property:
(M {title: "The Matrix"})//movie with a title property (a {name: "Keanu Reeves", born:1964})//actor with name and born Prope Rty
(a)-[:ACTED_IN {roles:["Neo"]}]->(m)
Relationship acted_in with roles property (an array of character names)
Label:
(A:person)//a person (A:person {name: ' Keanu Reeves '})//a person with properties (A:person)-[:acted_in]-> (M:movie)// A person that acted_in some movie
Query language used by neo4j Cypher
Http://www.uml.org.cn/sjjm/201203063.asp
The query language contains
Start: The starting point in the diagram is obtained by the ID of the element or so find. Match: The matching pattern of the graph, tied to the start point. WHERE: Filter conditions. Return: Returns the required.
Share site: http://www.cnblogs.com/rongyux/p/5537028.html
NEO4J First Use learning simple operation-cypher language use