Neo4j框架学习之二语法命令

文章目录

- - cypher语言

cypher语言

cypher是一种非常简洁的图查询语言，neo4j使用cypher语言进行图数据的curd操作

通用关键字

RETURN、ORDER BY、LIMIT、SKIP、WITH、UNWIND、UNION和CALL

标签	描述
RETURN	返回结果
ORDER BY	排序
LIMIT	限制查询数量
SKIP	跳过
WITH	使用WITH可以在将结果传递到后续查询之前对结果进行操作。操作可以是改变结果的形式或者数量
UNWIND	UNWIND将一个列表展开为一个行的序列(行转列)。
UNION	UNION语句用于将多个查询结果组合起来。
CALL	CALL语句用于调用数据库中的过程(procedure)。

读关键字

标签	描述
MATCH	用指定的模式检索数据库
OPTIONAL MATCH	用于搜索模式中描述的匹配项
WHERE	对查询数据进行过滤
Aggregation	支持使用聚合(Aggregation)来计算聚在一起的数据
LOAD CSV

写关键字

CREATE、MERGE、SET、DELETE、REMOVE、FOREACH和CREATEUNIQUE

标签	描述
CREATE	创建节点
MERGE	节点不存在创建，不存在覆盖
SET	设置节点属性
DELETE	删除节点
REMOVE	删除图元素的属性和标签
FOREACH
CREATE UNIQUE	创建唯一元素

CREATE语句

创建节点

// 创建节点
CREATE (xqx:Person { name: "Emil", from: "Sweden", klout: 99 })
// 创建节点                      
CREATE (szb:Person { name: "Sweden", from: "Tom", klout: 88 })    
//创建节点并为name设置唯一约束
CREATE CONSTRAINT ON (n:Person) ASSERT n.name IS UNIQUE;

CREATE -> 创建数据的子句
() -> 圆括号表示一个节点
xqx:Person -> 变量 ‘ee’ 和标签 ‘Person’ 表示新的节点
{} -> 花括号添加属性到节点里面涉及key/value的键值对

创建关系

//为创建的节点 添加关系
MATCH (xqx:Person {name:'Emil'}),(szb:Person {name:'Sweden'}) 
	   MERGE (xqx)-[r:父子]->(szb)

-[relation]- 表示无方向的关系
-[relation]-> 表示有方向的关系
-[r]-> 则给关系赋予一个变量名，方便对这个关系进行操作
-[r:配偶]-> 匹配关系为 配偶 的类型

创建有关系的节点

// 第一种写法
CREATE (zds:Person { name: "Johan", from: "Sweden", learn: "surfing" }),
(lzj:Person { name: "Ian", from: "England", title: "author" }),
(zds)-[:KNOWS {since: 2001}]->(lzj)
 
// 第二种写法                               
CREATE (n{name:“张三”}) - [r:FRIEND]->({bookname:“Cypher”})

CREATE UNIQUE语句

//创建唯一节点
MATCH (root { name: 'root' })
CREATE UNIQUE (root)-[:LOVES]-(someone)
RETURN someone
        
//创建唯一关系
MATCH (lft { name: 'A' }),(rgt)
WHERE rgt.name IN ['B', 'C']
CREATE UNIQUE (lft)-[r:KNOWS]->(rgt)
RETURN lft, rgt

SET语句

SET语句用于更新节点的标签以及节点和关系的属性。

//SET设置节点或者关系的属性 设置多个属性用逗号分隔
MATCH (n { name: ' Taylor Hackford' })
SET n.surname = 'Taylor'
RETURN n
//属性置为null的形式删除属性
MATCH (n { name: 'Taylor Hackford' })
SET n. surname = NULL
RETURN n
//节点之间拷贝属性
MATCH (at { name: 'Andres' }),(pn { name: 'Peter' })
SET at = pn
RETURN at, pn 
//当用map来设置属性时，可以使用+=形式的SET来只添加属性，而不删除图元素中已存在的属性。
MATCH (peter { name: 'Peter' })
SET peter += { hungry: TRUE , position: 'Entrepreneur' }             
// 用SET可给节点设置标签。
MATCH (n { name: 'Stefan' })
SET n :German
RETURN n

MERGE语法

MERGE 语法：不存在节点创建 create命令 ，存在节点则查询 match命令 并更新。

// merge语法其实就是create和match合并一起使用
merge (robert:Person {name: 'Robert'}) 
                       
//MERGE与CREATE搭配
//检查节点是否存在，如果不存在则创建它并设置属性。                       
MERGE (keanu:Person { name: 'Keanu Reeves' })
ON CREATE SET keanu.created = timestamp()
RETURN keanu.name, keanu.created    
    
//MERGE与MATCH搭配  
//匹配节点，并在找到的节点上设置属性。                       
MERGE (person:Person { name: 'Keanu Reeves2' })
ON MATCH SET person.found = TRUE
RETURN person.name, person.found   
  
//添加节点并设置name属性唯一性约束    
CREATE CONSTRAINT ON (n:Person) ASSERT n.name IS UNIQUE;
//（2）如果节点未找到，使用唯一性约束创建该节点
MERGE (laurence:Person { name: 'Laurence Fishburne' })
RETURN laurence.name
//本查询创建了'laurence'节点。如果'laurence'已经存在，MERGE 仅仅匹配已经存在的节点。
//（3）唯一性约束与部分匹配
//当只有部分匹配时，使用唯一性约束合并将失败。
CREATE CONSTRAINT ON (n:Person) ASSERT n.role IS UNIQUE;
//创建节点
CREATE (alisanda:Person { name: 'alisanda', role: 'Gordon Gekko' })
//合并节点部分匹配，此次之行会失败	                           
MERGE (michael:Person { name: 'Michael Douglas', role: 'Gordon Gekko' })
RETURN michael

MATCH语句

MATCH（用指定的模式检索数据库）

//查询所有节点 通过指定一个不带标签的节点的模式，将图数据库中的所有节点将返回
MATCH (n) RETURN n

//通过指定带有一个标签的节点的模式，可以获取满足该标签的所有节点。
MATCH (movie:Movie) RETURN movie.title

//查询关联节点
//返回’Lilly Wachowski’相关的所有关系的节点。
MATCH ({ name: 'Lilly Wachowski' })--(movie)
RETURN movie.title
  
//返回’Lilly Wachowski’相关的所有电影
MATCH (:Person { name: 'Lilly Wachowski' })--(movie:Movie)
RETURN movie.title

查找关系

//查找person有关系的节点信息  
//有方向的关系通过-->或者<--来表示。
//没有方向不添加方向箭头
MATCH (:Person { name: 'Lilly Wachowski' })-->(movie)
RETURN movie.title

//查询获取关系的类型
MATCH (:Person { name: 'Lilly Wachowski' })-[r]->(movie)
RETURN type(r)    

//查询指定关系的节点，多个关系以|分隔
//返回与'The Matrix'节点关系为ACTED_IN或者DIRECTED的所有节点。            
MATCH (wallstreet:Movie { title: 'The Matrix' })<-[:ACTED_IN|:DIRECTED]-(actor)
RETURN actor.name

//查询多个关系   返回'Tom Hanks'演的电影和该电影的导演。
MATCH (tom { name: 'Tom Hanks' })-[:ACTED_IN]->(movie)<-[:DIRECTED]-(director)
RETURN tom,movie, director
   
//返回与' Tom Hanks '关系为1跳(hop)到3跳的所有电影。
MATCH (martin { name: 'Tom Hanks' })-[:ACTED_IN*1..3]-(movie:Movie)
RETURN movie.title
                                                       
//返回与'Tom Hanks'直接相连的路径。
//如果想返回或者需要对路径进行过滤，可以将路径赋值给一个变量
MATCH p =(tom { name: 'Tom Hanks' })-->()
RETURN p
                 
//通过使用shortestPath函数很容易找到两个节点之间的最短路径。
//找到两个节点之间的最短路径，路径最大长度为15:
MATCH  p =shortestPath((tom { name: 'Tom Hanks' })-[*..15]-( Steve {name:'Steve Zahn'}))
RETURN p

根据id查找节点

//根据id查找节点
MATCH (n)
WHERE id(n)= 0
RETURN n

//根据id查找关系
MATCH ()-[r]->()
WHERE id(r)= 0
RETURN r

//根据id查找多个节点
MATCH (n)
WHERE id(n) IN [0, 3, 5]
RETURN n

OPTINAL MATCH 语句

OPTINAL MATCH语句用于搜索模式中描述的匹配项， 对于找不到的项用null代替。
如果某个关系是可选的，可使用OPTINAL MATCH 。

//查询 电影'The Matrix'的有关系的所有节点
MATCH (a:Movie { title: 'The Matrix' })
OPTIONAL MATCH (a)--(x)
RETURN x
//类似于
MATCH (a:Movie { title: 'The Matrix' }) --(x) return x
//查询电影The Matrix的关系             
MATCH (a:Movie { title: 'The Matrix' }) OPTIONAL MATCH (a)<-[r: ACTED_IN]-() RETURN r
//类似于
MATCH (a:Movie { title: 'The Matrix' })<-[r: ACTED_IN]-() RETURN r

WHERE语句

WHERE在MATCH或者OPTINAL MATCH语句中添加约束，或者与WITH一起使用来过滤结果

//返回发行日期介于1990~2000年的电影名称。
MATCH (nineties:Movie)
WHERE nineties.released > 1990 AND nineties.released < 2000
RETURN nineties.title

//返回拥有title属性的节点        
MATCH (n)
WHERE exists(n.title)
RETURN n 

//STARTS WITH用于以大小写敏感的方式匹配字符串的开始。
//返回名字以"Tom"开始的节点。
MATCH (n)
WHERE n.name STARTS WITH 'Tom'
RETURN n

//ENDS WITH用于以大小写敏感的方式匹配字符串的结尾。
//返回了姓名以'Hanks'结尾的人。
MATCH (n)
WHERE n.name ENDS WITH 'Hanks'
RETURN n  

//CONTAINS用于检查字符串中是否包含某个字符串(大小写敏感)
MATCH (n)
WHERE n.name CONTAINS 'bin'
RETURN n      
       
//使用NOT关键词可以返回不满足给定字符串匹配要求的结果。
//返回了姓名不以"s"结尾的人。 
MATCH (n)
WHERE NOT n.name ENDS WITH 's'
RETURN n   
      
//正则表达式
//可以使用=~ 'regexp'来进行正则表达式模糊匹配
MATCH (n)
WHERE n.name =~ 'Tom.*'
RETURN n  
       
//在正则表达式前面加入(?i)之后，整个正则表达式将变成非大小写敏感
MATCH (n)
WHERE n.name =~ '(?i)TOM.*'
RETURN n   
  
//模式过滤 
MATCH (n { name:'Kevin Bacon'}),(m)
WHERE (n)-[:ACTED_IN]-(m)
RETURN n,m      
     
//返回所有导演。                       
MATCH (n)-[r]->()
WHERE type(r)=~ 'DIRE.*'
RETURN n   
//IS NULL  大于> 小于< 不等于<> 都可以用在where上

DELETE语句

DELETE 语句用于删除节点和关系。

//删除都是先查询到再进行删除
//删除节点
match(p:BlackPirates) detach delete p
//删除指定名字的节点 detach顺便删除关系
match(p:BlackPirates) where p.name <> "蒂奇" detach delete p
match(p:BlackPirates {name:"希留"})  detach delete p
//删除关系
match(p:BlackPirates)-[r:伙伴]-(p:StrawHatPirates) delete r  
//删除路径（节点、关系都会删除）
match p=(d { name: 'Node D' })--(e { name: 'Node e' })
delete p

REMOVE语句

REMOVE 语句用于删除图元素的属性和标签。

//Neo4j不允许属性存储空值null。如果属性的值不存在，
//那么节点或者关系中的属性将被删除。这也可以通过REMOVE来删除
MATCH (p { name: 'Michael Douglas' })
REMOVE p. name
RETURN p
    
//删除节点的某个属性
CREATE (p { name: 'Michael Douglas',German:'F' })
MATCH (p { name: 'Michael Douglas' })
REMOVE p:German
RETURN p

//删除节点多个标签
MATCH (n { name: 'Michael Douglas' })
REMOVE n:German:Swedish
RETURN n

ORDER BY语句

ORDER BY是 紧跟RETURN或者WITH的子句 ，它指定了输出的结果应该如何排序

//对输出进行排序，多个节点排序 逗号分隔
MATCH (n)
RETURN n.name
ORDER BY n.name desc

//当结果集中包含null值时，对于升序排列，
//null总是在结果集的末尾。而对于降序排序，null值总是排在最前面。

LIMIT语句

LIMIT限制输出的行数

//查询出来的数据跳过1条取中间两条
MATCH (n)
RETURN n
ORDER BY n.name
[SKIP 1]
[LIMIT 2]

WITH语句

WITH语句将分段的查询部分连接在一起，查询结果从一部分以管道形式传递给另外一部分作为开始点

//聚合的结果必须要通过WITH语句传递才能进行过滤。
MATCH (david { name: 'Tom Hanks' })--()--(otherPerson)
WITH otherPerson, count(*) AS foaf
WHERE foaf > 1
RETURN otherPerson

//可以在将结果传递给collect函数之前对结果进行排序，这样就可以返回排过序的列表。
MATCH (n)
WITH n
ORDER BY n.name DESC LIMIT 3
RETURN collect(n.name)

//可以限制匹配路径的数量，然后以这些路径为基础再做任何类似的有限制条件的搜索。
MATCH (n { name: 'Tom Hanks' })--(m)
WITH m
ORDER BY m.name DESC LIMIT 1
MATCH (m)--(o)
RETURN o.name

FOREACH

*FOREACH语句用于循环遍历结果集列表，然后做一些操作。

列表(lists)和路径(paths)是Cypher中的关键概念。可以使用FOREACH来更新其中的数据。它可以在路径或者聚合的列表的每个元素上执行更新命令。FOREACH括号中的变量是与外部分开的，这意味着FOREACH中创建的变量不能用于该语句之外。

在FOREACH括号内，可以执行任何的更新命令，包括CREATE，CREATE UNIQUE，DELETE和FOREACH。如果希望对列表中的每个元素执行额外的MATCH命令，使用UNWIND命令更合适。

//这个查询将设置路径上所有节点的marked属性为true值。
//即为root以及与root有关系的所有节点设置属性marked
MATCH p = (root { name: 'root' })-[r]-(A)
FOREACH (n IN nodes(p)| SET n.marked = TRUE )

//为a添加多个朋友
MATCH (a {name: 'root' })
FOREACH (name IN ["Mike", "Carl", "Bruce"] 
CREATE (a)-[:FRIEND]->(:Person {name: name}))

Aggregation 聚合函数

Cypher支持使用聚合(Aggregation)来计算聚在一起的数据，类似SQL中的group by，常见函数为 count()、sum()、avg()、max()、min()等

//count函数 计算数量
MATCH (n)
RETURN count(n.title)
//sum函数 求和
MATCH (n:Person)
RETURN sum(n.property)
//avg 求平均值
MATCH (n:Person)
RETURN avg(n.property)
//distinct去重
MATCH (b)
RETURN count(DISTINCT b.eyes)           
//max查找数值列中的最大值。
MATCH (n:Person)
RETURN max(n.property)
//min查找数值列中的最小值。
MATCH (n:Person)
RETURN min(n.property)
//collect将所有的值收集起来放入一个列表。空值null将被忽略。
MATCH (n:Person)
RETURN collect(n.property)

UNWIND语句

UNWIND将一个列表展开为一个行的序列(行转列)。

//将行数据 转换为一列
WITH [1, 2, 3, 4] AS coll
UNWIND coll AS x return x

//数组 去重后准换为集合
WITH [1, 1, 2, 2] AS coll
UNWIND coll AS x
WITH DISTINCT x
RETURN collect(x) AS SET

UNION语句

UNION语句用于将多个查询结果组合起来。

//用UNION ALL将两个查询的结果组合在一起，可能包含重复行。
MATCH (n:Actor)
RETURN n.name AS name
UNION ALL
MATCH (n:Movie)
RETURN n.title AS name

//在UNION中不使用ALL时，组合的结果集中会去掉重复值。
MATCH (n:Actor)
RETURN n.name AS name
UNION
MATCH (n:Movie)
RETURN n.title AS name

原文链接：https://blog.csdn.net/liushangzaibeijing/article/details/128647037