Neo4j之增删改查（cypher）

// 新增节点    
// 注意，同一次执行时，别名可以跨语句使用    
CREATE (pp:Person {name: 'pp'})     
CREATE (yx:Person {name: 'yx'})     
CREATE (xy:Person {name: 'xy'})     
CREATE (xx:Person {name: 'xx'})     
CREATE (cc:Person {name: 'cc'})     
CREATE (lyon:Person {name: 'lyon'})     
CREATE (jason:Person {name: 'jason'})     
// 新增关系    
// 注意，新增关系时，节点需要打括号，否则报错    
CREATE (jason)-[:FRIEND]->(lyon)-[:FRIEND]->(pp)     
CREATE (yx)-[:FRIEND]->(xy)-[:FRIEND]->(xx)-[:FRIEND]->(cc)    
// 新增路径    
CREATE p =(mars:person { name:'mars',title:'AIleader' })-  
[:WORKS_AT{level:12}]->(kp:company{name:'kp',addr:'dl'})<-[:WORKS_AT]-  
(keven:leader { name: 'keven' ,title:'CEO'})  

// 属性key名与现有完全一致，但是title的value不一致，因此会新增节点  
merge (n:person { name: 'mars',title:'data leader'})   


// 缺了title属性，但是name属性的key和value与现有node一致，故不会新增  
merge (n:leader { name: 'keven'})   
  
// 新增关系和新增节点使用方式一致  
match (jason:Person {name:'jason'}),(pp:Person {name:'pp'})  
merge (jason)-[r:FRIEND {name:"new"}]->(pp)    


// 可以同时新增节点、关系  
merge (cc2:Person {name:'cc2'})-[r2:FRIEND2]->(xx2:Person {name:'xx2'})  

// 删除指定节点    
// 注意，节点有关系时会删除失败    
MATCH (e:Person) DELETE e    
// 删除指定节点，若有关系，则一起删除    
match (m: Person) where m.name = 'jason' DETACH delete m   
// 删除关系    
match (n:leader {name:'keven'})-[r: WORKS_AT]-() delete r   

// 新增属性  
match  (cc:Person {name: 'cc'})   
set cc.sex='girl'  
  
// 先过滤，再set  
MATCH (n { name: 'mars' })  
where n.title = 'data leader'   
set n.age = 18  
RETURN n.name,  n.age  
  
// 节点间属性替换  
MATCH (cc { name: 'cc' }),(cc2{ name: 'cc2' })  
SET cc2 = cc  
  
// 节点属性用map替换  
MATCH (xx{ name: 'xx' })  
SET xx = { name: 'xx', age: 18 }  

// 移除属性  
match  (keven:leader {name: 'keven'})   
remove keven.title  
  
// 移除标签  
MATCH (n { name: 'lyon' })  
REMOVE n:Person  

// 查询节点，并返回属性(朋友的朋友）    
MATCH (yx{name: 'yx'})-[:FRIEND]->()-[:FRIEND]->(xx)    
RETURN yx.name, xx.name        
// return *表示返回所有元素    
match(n:Person)    
return *    
// 查询到的a及a的叶子节点      
MATCH (a:person { title: 'AIleader' })      
MATCH (a)-->(x)      
RETURN a,x           
// 查询a的关系    
MATCH  (a:person { title: 'AIleader' })    
MATCH (a)-[r:WORKS_AT]->()    
RETURN a.title, r    

// 查询与yx连接的第二层节点  
match (n:Person {name:'yx'})-[*2]->(m:Person)  
return m;  
  
// 指定关系层数范围查询  
match(a:Person{name:'yx'})-[*1..3]->(b)  
return b;  
  
// 指定和yx关联的关系层数大于某个值  
match(a:Person{name:'yx'})-[*2..]->(b)  
return b;  
  
// 指定和yx关联的关系层数小于某个值  
match(a:Person{name:'yx'})-[*..2]->(b)  
return b;  
  
// 查询所有关系的节点（不指定层数）  
match(a:Person{name:'yx'})-[*]->(b)  
return b; 

// 查询节点和关系  
MATCH p =(yx:Person)-[*]-(cc:Person)  
WHERE yx.name = 'yx' AND cc.name = 'cc'  
RETURN p  

// 正则查询  
MATCH (n)-[:FRIEND]->(m)  
WHERE n.name IN ['yx', 'xx'] AND m.name =~ 'x.*'  
RETURN n.name, m.name  
  
// 标签过滤  
MATCH (n)  
WHERE n:person  
return n  
  
// 判断是否存在属性并过滤  
MATCH (n)  
WHERE exists(n.realName)  
RETURN n  
  
// 根据关系的type过滤  
MATCH (n)-[r]->()  
WHERE n.name='xy' AND type(r)=~ 'F.*'  
RETURN type(r), r

//为了实现下一个脚本，新增一组关系
//因为之前有两个name：cc ，所以yx对cc一个是新建了关系，一个是更新了关系  
match (yx:Person {name:'yx'}),(cc:Person {name:'cc'})    
merge (yx)-[r:FRIEND {name:"new"}]->(cc)     
  
// 查询yx的朋友数量  
MATCH (n {name: 'yx'})-[:FRIEND]-(friend)   
WITH n, count(friend) AS friendsCount   
WHERE friendsCount > 1   
RETURN n, friendsCount  
  
// 先查后改，n多了个属性  
MATCH (n {name: 'yx'})-[:FRIEND]-(friend)   
WITH n, count(friend) AS friendsCount   
SET n.friendsCount = friendsCount  
RETURN n, friendsCount  

MATCH (n)  
WHERE id(n)= 0  
RETURN n  
  
MATCH ()-[r]->()  
WHERE id(r)= 0  
RETURN r  
 
MATCH (n)  
WHERE id(n) IN [0, 3, 5]  
RETURN n