Neo4J图数据库入门记录

发布时间 2023-07-06 10:19:03作者: 面向对象爱好者社区

Neo4J图数据库

CQL语法

1、create命令

创建一个没有属性的节点

create (<node-name>:<lable-name>)

创建具有属性的节点

create (<node-name>:<lable-name>{<property1-name>:<property1-value>,……})

2、match命令

1.无条件查询
match (node-name:lable-name) return node-name //注意需要与return搭配使用
2.有条件查询
match (node-name:lable-name)
where node-name.property='ceshi'
return node-name
3.查询所有节点
match (n) return n
4.查询所有节点的标签
match (n) return distinct labels(n)

3、return命令

return 需与match或create+match搭配使用

4、关系基础

Neo4j图数据库遵循属性图模型来存储和管理其数据

根据属性图模型,关系应该是定向的。否则,Neo4j将抛出一个错误的信息。

基于方向性,neo4j划为单向关系和双向关系

现有节点创建没有属性的关系

MATCH (<node1-label-name>:<nodel-name>),(<node2-label-name>:<node2-name>)
CREATE  
(<node1-label-name>)-[<relationship-label-name>:<relationship-name>{<define-properties-list>}]->(<node2-label-name>)
RETURN <relationship-label-name>

现有节点创建有属性的关系

MATCH (cust:Customer),(cc:CreditCard) 
CREATE (cust)-[r:DO_SHOPPING_WITH{shopdate:"12/12/2014",price:55000}]->(cc)
RETURN r

新节点创建没有属性的关系

CREATE  
  (<node1-label-name>:<node1-name>)-
  [<relationship-label-name>:<relationship-name>]->
  (<node1-label-name>:<node1-name>)
RETURN <relationship-label-name>

新节点创建有属性的关系

CREATE  
(<node1-label-name>:<node1-name>{<define-properties-list>})-
[<relationship-label-name>:<relationship-name>{<define-properties-list>}]
->(<node1-label-name>:<node1-name>{<define-properties-list>})
RETURN <relationship-label-name>

create创建标签

单个标签到节点

CREATE (<node-name>:<label-name>)

多个标签到节点

CREATE (<node-name>:<label-name1>:<label-name2>.....:<label-namen>)

单个标签到关系

CREATE (<node1-name>:<label1-name>)-
[<relationship-name>:<relationship-label-name>]
->(<node2-name>:<label2-name>)

where子句

布尔运算符

 

比较运算符

 

使用where子句创建关系

MATCH (<node1-label-name>:<node1-name>),(<node2-label-name>:<node2-name>) 
WHERE <condition>
CREATE (<node1-label-name>)-[<relationship-label-name>:<relationship-name>
      {<relationship-properties>}]->(<node2-label-name>)

Delete删除

  • 删除节点

  • 删除节点以及相关节点和关系

删除没有带关系的节点

MATCH (e: Employee) DELETE e

删除带关系的节点

MATCH (cc: CreditCard)-[rel]-(c:Customer) 
DELETE cc,c,rel

remove删除

  • 删除节点或关系的标签

  • 删除节点或关系的属性

  • delete与remove不能单独使用要与match一起使用

删除节点的标签

方法1
match (m) <节点名称>
where m.name="电影或图片" <添加对应的条件筛选>
remove m:Movie <要删除的节点关联的标签名>
return m <返回节点数据>
方法2
match
(m:Movie) <多标签的其中一个>
remove m:Picture <删除Picture标签>

删除节点的属性

方法1
match
(a)
where a.name="电影和图片"
remove a.name
return a
方法2
match
(m:Movie)
remove m.name
return m

set子句

向现有节点添加属性

match (m:Picture) set m.name="只含图片" return m

向现有节点的关系添加添加属性

match (s1)-[f:FRIEND]->(s2)
where s1.name="张三" and s2.name="李四"
set f.relation="他们是朋友"
return s1,s2

MATCH (:Person {name: 'Alice'})-[f:FOLLOWS]->(:Person {name: 'Bob'})
SET f.status = 'active'
RETURN f

order by排序

默认升序,降序用desc

MATCH (emp:Employee)
RETURN emp.empid,emp.name,emp.salary,emp.deptno
ORDER BY emp.name DESC

union合并

同sql一样union和union all

注意:因为两个查询有不同的节点名称为了避免错误需要用as给每个字段起一个统一的别名,或者用同一个节点名称(此处不会报错)

MATCH (cc:CreditCard)
RETURN cc.id as id,cc.number as number,cc.name as name,
  cc.valid_from as valid_from,cc.valid_to as valid_to
UNION
MATCH (dc:DebitCard)
RETURN dc.id as id,dc.number as number,dc.name as name,
  dc.valid_from as valid_from,dc.valid_to as valid_to

limit和skip

MATCH (emp:Employee) 
RETURN emp
limit 2

MATCH (emp:Employee)
RETURN emp
SKIP 2

merge合并

merge=create+match

如果不存在图中,则它新建节点/关系并返回结果,反之则不新建

MERGE (gp2:GoogleProfile2{ Id: 201402,Name:"Nokia"})

null和in

null、in关键字符合sql用法
is null 或者 is not null
in搭配where 进行筛选

ID属性

在neo4j中id是节点或关系默认的内部属性。这意味着,当我们创建一个新的节点或关系的时候,Neo4j数据库服务器将为内部分配一个数字,它会自动递增。

caption标题

在Neo4j数据中,当我们在Neo4j DATA浏览器中执行MATCH + RETURN命令以查看UI视图中的数据时,通过使用它们的Id属性显示节点和/或关系结果。 它被称为“CAPTION”的id属性。

方向关系

在neo4j中,两个节点之前的关系是有方向性的。它是单向或者双向的。

由于Neo4j遵循属性图数据模型,它应该支持方向关系。如果创建一个没有方向的关系

CQL函数

字符串函数

1.upper 它用于将所有字母更改为大写字母。
MATCH (e:Employee)
RETURN e.id,UPPER(e.name),e.sal,e.deptno
2.lower 它用于将所有字母更改为小写字母。
MATCH (e:Employee)
RETURN e.id,LOWER(e.name),e.sal,e.deptno
3.subtring 一个是索引的开始,另一个是返回从StartInded到EndIndex的子字符串
MATCH (e:Employee)
RETURN e.id,SUBSTRING(e.name,0,2),e.sal,e.deptno
4.replace 它用于替换一个字符串的子字符串。
MATCH (p:Person)
WHERE p.name CONTAINS 'John'
SET p.name = REPLACE(p.name, 'John', 'Jonathan')
RETURN p

聚合函数(AGGREGATION)

COUNT、MAX、MIN、SUM、AVG

关系函数

用以获取开始节点、结束节点等细节时知道关系的细节

startnode:用于知道关系的开始节点
MATCH (a)-[movie:ACTION_MOVIES]->(b)
RETURN STARTNODE(movie)
endnode:用于知道关系的结束节点
MATCH (a)-[movie:ACTION_MOVIES]->(b)
RETURN ENDNODE(movie)
id:它用于知道关系的id
type:它用于知道字符串表示的一个关系的type
MATCH (a)-[movie:ACTION_MOVIES]->(b)
RETURN ID(movie),TYPE(movie)

管理员

数据库备份和恢复

索引

创建索引语法
create index on:Customer (name)
删除索引语法
drop index on:Customer(name)

unique约束

创建唯一约束语法
create constraint on (cc:CreditCard)
Assert cc.number is unique

drop unique

drop constraint on (cc:CreditCard)
Assert cc.number is unique

 

Springboot集成neo4j实现知识图谱关系图

https://blog.csdn.net/qq_48329942/article/details/130079049

 

新数据源测试2 273615320605446144

 

JsonArray dataArray = JsonParser.parseString(panelData).getAsJsonArray();

 

create (:Person{name:'张三'})

match (n:Person)  match (m:Person)
where n.name = '张三' and m.name = '杨旭'
create (n) -[r:`学生`] ->(m)
return r

match (n:Person), (m:Person)
where n.name = '张三' and (m.name = '张鑫')
create (n) -[r:`室友`] -> (m)
return r

MATCH (n:Person {name: '张三'})-[r:`学生`]->() delete r

-- 创建一个空关系
CREATE ()-[:RELATIONSHIP]->()

CREATE ()-[:manage_10001012{projectId:'10001012',name:'manage',cusType:'manage_10001012',remark:'只是备注'}]->()

CREATE ()-[:归属_10001012{projectId:'10001012',name:'归属',cusType:'归属_10001012',remark:'只是备注'}]->()

-- 查询关系
MATCH p=()-[r:RELATIONSHIP]->() RETURN p LIMIT 25

-- 删除关系
MATCH p=()-[r:属于]->() delete p

-- 查找属性
MATCH (n) WHERE EXISTS(n.age) RETURN DISTINCT "node" as entity, n.age AS age LIMIT 25 UNION ALL MATCH ()-[r]-() WHERE EXISTS(r.age) RETURN DISTINCT "relationship" AS entity, r.age AS age LIMIT 25


match (n:Person), (m:Person)
where (n.name = "张鑫" or n.name = "刘超") and m.name = "杨旭"
create (n) -[r:`学生`]->(m)
return r

create (:Person{name:"刘超"})


match (n:Person), (m:Person)
where n.name = "陈敏" and m.name = "刘超"
create (n) -[r:`情侣`]->(m)
return r
-- 指定删除关系,节点保留
MATCH (n:Person {name: '陈敏'})-[r:`情侣`]->() delete r
-- 删除该Person所有的关系。节点保留
MATCH (n:Person)-[r:`情侣`]->() delete r
MATCH (n:施工工具)-[r:`未知关系`]->() delete r

match (n:`工具`), (m:`工具`)
where n.name = "螺丝刀" and m.name = "钳子"
create (n) -[r:`情侣`] -> (m)
return r


match (n:`施工工具`)-[old]->(m:`施工工具`)
where id(n) = 100353 and id(m) = 100641
delete old

-- 删除所有关系
MATCH (n)-[r:`情侣`]->() delete r

BuildGraphController

MATCH (n)-[r:`同事`]->() delete r


MATCH (t:本体 {name:'人物'}) CREATE (p:实体 {name:'张三',age:46})-[:属于]->(t)


CREATE ()-[:同事{remark:"用于公司里人员之间关系"}]->()

CREATE ()-[:同事{remark:'用于公司里人员之间关系'}]->()

MATCH ()-[r:`朋友`]->() WHERE ID(r) = 62 return r

MATCH ()-[r:`朋友`]->() WHERE ID(r) = 62 delete r


MATCH ()-[r]->() WHERE ID(r) = 98 return r


MATCH ()-[r]->() WHERE ID(r) = 117 return ID(r) as id, r.remark

MATCH ()-[r]->() RETURN DISTINCT type(r)

重命名关系
https://www.codenong.com/13816712/

//String cql = "MATCH ()-[r]->() where type(r) CONTAINS '"+ request.getRelationshipName() +"' RETURN DISTINCT type(r) as relationshipName";


MATCH (n:`工具`), (m:`工具`)
where id(n) = 168 and id(m) = 143
create (n) -[r:`情侣`] -> (m)
return r

-- 根据节点id,查询节点及其所有关系节点
MATCH P=(n)<--(m) where id(n) = 166 RETURN P
union
MATCH P=(n)-->(m) where id(n) = 166 RETURN P

MATCH P=(n:Person)<--(m) where id(n) = 166 RETURN P union MATCH P=(n:Person)-->(m) where id(n) = 166 RETURN P

// MATCH P=(n:%s)<--(m) where id(n) = %s RETURN P union MATCH P=(n:%s)-->(m) where id(n) = %s RETURN P
       
MATCH (n:Country), (m:Person)
where n.name = '中国' and m.name = '孙悟空'
create (n) <-[r:属于] -(m)
return r


MATCH P=(n:Country)<--(m) where id(n) = 27 RETURN P
union
MATCH P=(n:Country)-->(m) where id(n) = 27 RETURN P
union match P=(n:Country) where id(n) = 27 return P


-- 根据名称搜索知识图谱
MATCH P=(n)<--(m) where n.name contains '张三' RETURN P
union
MATCH P=(n)-->(m) where n.name contains '张三' RETURN P
union match P=(n) where n.name contains '张三' return P

-- 两个节点构建关系
//MATCH (n:`工具`), (m:`工具`) where id(n) = 168 and id(m) = 143 create (n) -[r:`情侣`] -> (m) return r

-- 查询两个节点之间的关系
MATCH (n:Country)-[r:属于]->(m:Test)
WHERE ID(r) = 125 and id(n) = 27 and id(m) = 7
return r

//MATCH (n:Country)- [r] ->(m:Person) WHERE ID(r) = 120 and id(n) = 27 and id(m) = 61 delete r



match (n)-[r:情侣]->(m) return r


match (n)-[old:拥有2]->(m) create (n)-[new:拥有]->(m) delete old


// 关系名没有修改,改属性-备注的话
// MATCH p=()-[r:归属]->() SET r={remark:'有备注'} RETURN p
           
create (:Country{name:'火星国',age:500})

match(n:Country), (m:Country)
where n.name='中国' and m.name = '火星国'
create (n)-[r:`同事2`]->(m)
return r

create (:Test{name:'马马',age:18})


-- 查询两个节点之间的关系
MATCH (a:Country)<-[r]-(b:Person)
WHERE a.name = '中国' AND b.name = '孙悟空'
RETURN type(r) as relation

 

执行脚本封装

https://stackoverflow.com/questions/66594767/neo4j-java-driver-cannot-access-records-on-this-result

//for (Map<String, Object> map : mapList) {
//   Object p = map.get("P");
//   JSONObject jsonObject = JSONUtil.parseObj(p);
//   System.out.println(jsonObject);
//   System.out.println(p);
//}

 

-- 创建模型
create (:Model{name:"模型",remark:"备注来的", version:1.0})

-- 创建本体
create (:本体{id:1, name:"施工工具"})
create (:本体{id:2, name:"接入式电子"})
create (:本体{id:3, name:"电子计量装置"})
create (:本体{id:4, name:"人员"})

-- 创建模型与本体之间的关系
match(n:Model), (m:`本体`)
where n.name = "模型"
create (n) -[r:manage]->(m)
return r

-- 创建实体
create (:实体{id:1, name:"螺丝刀"})
create (:实体{id:2, name:"锤子"})
create (:实体{id:3, name:"塔吊机"})
create (:实体{id:4, name:"鲁一"})
create (:实体{id:5, name:"杨旭"})
create (:实体{id:6, name:"装车秤"})
create (:实体{id:7, name:"三相电能表"})

create (:实体{id:8, name:"绝缘梯"})
create (:实体{id:9, name:"脚扣踩板"})


-- 创建实体与本体(施工工具)之间的关系
match(n:`本体`), (m:`实体`)
where n.name = '施工工具' and m.id<4
create (m) -[r:属于] -> (n)
return r

-- 创建实体与本体(人员)之间的关系
match(n:`本体`), (m:`实体`)
where n.name = '人员' and m.id>=4
create (m) -[r:属于] -> (n)
return r

match(n:`本体`), (m:`实体`)
where n.name = '电子计量装置' and m.id>5
create (m) -[r:属于] -> (n)
return r

match(n:`本体`), (m:`实体`)
where n.name = '施工工具' and m.id>7
create (m) -[r:属于] -> (n)
return r


-- 删除实体,于本体两个节点之间的关系
MATCH (n:实体)- [r] ->(m:本体) WHERE id(r) = 8 and id(n) = 9 and id(m) = 1 delete r



MATCH (s:实体)-[r:`属于`]->(b:本体)
where ('施工工具' IS NULL OR b.name CONTAINS '施工工具')
RETURN s order by s.id desc  

skip 0 limit 3  9,8,7
Integer page = request.getPage();
Integer limit = request.getLimit();
int skip = (page - 1) * limit;
       
-- 分页查询
MATCH (s:实体)-[r:`属于`]->(b:本体)
RETURN s.id, s.name, id(s) as nodeId, labels(s) as label, s order by s.id desc skip 3 limit 3


match (n:Coder), (m:Country)
where n.name = '张三' and m.name = '中国'
create (n)<-[r:`友邻`]-(m)
return r

-- 查询有多少个关系type
MATCH ()-[r]->() RETURN count(distinct type(r))

-- 统计所有节点个数
MATCH (n)
RETURN count(n)

-- 统计label个数
MATCH (n)
RETURN count(distinct labels(n))

MATCH (n)
RETURN size(keys(n))

-- 统计属性个数,多个list要合并,且去重 用set
MATCH (n)
RETURN distinct keys(n)


match (n) where n.remark is not null return count(*)

MATCH ()-[r]->() where type(r) CONTAINS $relationshipName RETURN DISTINCT type(r) as relationshipName

--
match p=(n:Country)-[r*1]-(m) where n.name contains '中国' return p


-- 有排序的
MATCH ()-[r]->() where type(r) CONTAINS '' with r order by elementId(r) desc RETURN DISTINCT type(r) as relationshipName, r.remark as remark SKIP 0 LIMIT 20



MATCH p=()-[r:归属]->() SET r={remark:'有备注',age:19,sex:1} RETURN p


待办:
新建关系的,需要一些默认值, 项目id

关系唯一名称,需要用项目id拼接


-- 覆盖掉原来的所有属性
MATCH (n:`施工工具`) SET n={projectId:1}  RETURN n LIMIT 25

-- 修改一个节点的属性
MATCH (n:`本体`) where id(n) = 4 set n.name = '人员' RETURN n LIMIT 25



match (n:`施工工具`)-[old:`未知关系`]->(m:`施工工具`)
where id(old) = 360 and id(n) = 100353 and id(m) = 100641
create (n) -[new:未知关系的2]->(m)
delete old


match (n:`施工工具`)-[old:`未知关系`]->(m:`施工工具`)
where id(old) = 360 and id(n) = 100353 and id(m) = 100641
delete old

match (n2:`施工工具`), (m2:`施工工具`)
where id(n2) = 100353 and id(m2) = 100641
create (n2) -[new:未知关系的2]->(m2)


-- 删除关系,保留节点
MATCH (n:施工工具)-[r:`未知关系的修改`]->() delete r



修改关系名时,要判断关系有没有关系id,

保存时,删掉原来的关系,再用新的值创建关系



match (n:`施工工具`) where id(n) = 100402 return n


match (n2:`施工工具`), (m2:`施工工具`)
where id(n2) = 100382 and id(m2) = 100402
create (n2) -[new:我修改的]->(m2)