neo4j图数据库

目录

• neo4j说明
• docker-compose安装
• 命令
  • 创建节点
  • 创建节点关系
  • 创建节点并建立关系
  • 更新节点和关系
  • 查询节点和关系
  • 删除节点及关系
• golang执行cypher命令--创建节点
• golang执行cypher命令2--创建节点+建立关系

neo4j说明

	Neo4j是一个高性能的NOSQL图形数据库，它将结构化数据存储在网络上而不是表中。它是一个嵌入式的、基于磁盘的、具备完全的事务特性的Java持久化引擎，但是它将结构化数据存储在网络（从数学角度叫做图）上而不是表中。在Neo4j中，数据以图（网络）的形式而非传统的表的形式进行存储。这种图模型中，数据以节点（顶点）和边的方式表示，节点可以表示实体，而边则表示这些实体之间的各种关系。

这种数据模型的主要优点在于其快速解决复杂关系问题的能力。在Neo4j中，底层数据存储专门针对图形数据的特点进行了优化，因此在处理关系数据方面比其他数据库有更高的性能。另外，由于Neo4j没有表结构的概念，程序员可以在一个面向对象的、灵活的网络结构下工作，而非严格、静态的表结构，因此它比SQL更灵活。

Neo4j因其嵌入式、高性能、轻量级等优势，越来越受到关注。

docker-compose安装

version: '3'
services:
  neo4j:
    image: neo4j:4.4.27
    ports:
      - 7474:7474
      - 7687:7687
    volumes:
      - ./data:/data
      - ./logs:/logs
    environment:
      - NEO4J_AUTH=neo4j/123456

本地访问：http://127.0.0.1:7474/

命令

创建节点

//创建节点
CREATE (node:Label {property: value})
eg:
CREATE (us:country {name: "美国"});
CREATE (ch:country {name: "中国"});
CREATE (sichuan:area {name: "四川省"});
CREATE (jiangsu:area {name: "江苏省"});
CREATE (henan:area {name: "河南省"});
CREATE (hubei:area {name: "湖北省"});
CREATE (shanghai:city {name: "上海市"});
CREATE (beijing:city {name: "北京市"});

a:Person :标签-->a属于Person标签
b:Person :标签-->b属于Person标签

//创建带有多个标签和属性的节点
CREATE (node:Label1:Label2 {property1: value1, property2: value2})
eg:
CREATE (a:Person:Person2 {name: "jeffTest",age:18});
CREATE (a:Person:Person2 {name: "jeffTest",age:18})

创建节点关系

//创建节点关系
MATCH (node1:Label1),(node2:Label2)
CREATE (node1)-[:RELATIONSHIP_TYPE]->(node2)

eg:
//北京市属于中国关系
MATCH (n:city {name: "北京市"})
MATCH (ch:country {name: "中国"})
CREATE (n)-[:属于]->(ch);

//上海市属于中国关系
MATCH (n:city {name: "上海市"})
MATCH (ch:country {name: "中国"})
CREATE (n)-[:属于]->(ch);

//带有area标签的全部属于ch:country标签
MATCH (n:area)
MATCH (ch:country {name: "中国"})
CREATE (n)-[:属于]->(ch)

创建节点并建立关系

//创建节点并建立关系
CREATE (bazhong:city {name: "巴中市"})
MATCH (n:city {name: "巴中市"}),(ch:country {name: "中国"})
CREATE (n)-[:属于]->(ch)


//创建节点并建立关系
CREATE (kunshan:city {name: "昆山市"});
MATCH (n:city {name: "昆山市"}),(k:area {name: "江苏省"})
CREATE (n)-[:属于]->(k)

更新节点和关系

//更新节点属性
MATCH (n:city {name: "巴中市"})
SET n.peopNum = "200万"


//更新关系属性
MATCH (n:city {name: "巴中市"})-[r:属于]->(k:city {name: "上海市"})
MATCH (y:area {name: "四川省"})
DELETE r
CREATE (n)-[:属于]->(y)

查询节点和关系

//查询所有节点和关系
MATCH (node)
RETURN node

//查询满足条件的节点
MATCH (node:city)
WHERE node.name = "北京市"
RETURN node

//查询节点关系
MATCH (node1)-[relationship:属于]->(node2)
RETURN node1, relationship, node2

//查询满足条件的节点关系
MATCH (n:city)-[:属于]->(k:area)-[:属于]->(j:country)
WHERE n.name = "安阳市"
RETURN n, k,j
//查询满足条件的节点关系2
MATCH (n:city {name:"安阳市"})-[:属于]->(k:area)-[:属于]->(j:country)
RETURN n, k,j

删除节点及关系

//删除节点及关机
MATCH (n:city {name: "巴中市"})
OPTIONAL MATCH (ch:country {name: "中国"})-[relationship]-()
DELETE n, relationship

//删除节点关系
MATCH (n:city {name: "巴中市"})-[relationship]-()
DELETE relationship

//删除节点
MATCH (n:city {name: "新乡市"})
DELETE n

//删除所有节点关系
MATCH ()-[r]-() DELETE r  // 匹配所有节点之间的关系
//删除所有节点
MATCH (n)  DELETE n

golang执行cypher命令--创建节点

package main

import (
	"fmt"
	"github.com/neo4j/neo4j-go-driver/v4/neo4j"
)

func main() {
	config := func(conf *neo4j.Config) {
		//conf.Encrypted = false                         // 启用 TLS
		//conf.TLSCertFile = "/path/to/certificate.crt" // 设置 TLS 证书文件路径
		//conf.TLSKeyFile = "/path/to/private.key"      // 设置 TLS 私钥文件路径
		//conf.TLSCAFile = "/path/to/ca.crt"            // 设置 TLS CA 证书文件路径
	}

	// 创建驱动程序
	driver, err := neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "123456", ""), config)
	if err != nil {
		// 处理错误
	}
	defer driver.Close()
	session := driver.NewSession(neo4j.SessionConfig{})
	defer session.Close()
	
  //命令
	cyhperStr := `
MATCH (n:city {name: "巴中市"})-[r:属于]->(sichuan:area {name: "四川省"})
MATCH (shanghai:city {name: "上海市"})
DELETE r
CREATE (n)-[:属于]->(shanghai)
`

	result, err := session.WriteTransaction(func(tx neo4j.Transaction) (interface{}, error) {

		result, err := tx.Run(cyhperStr, nil)
		if err != nil {
			return nil, err
		}

		return result, nil
	})
	if err != nil {
		// 处理错误
		fmt.Println("err:", err)
		return
	}
	fmt.Println(result)
}

golang执行cypher命令2--创建节点+建立关系

package main

import (
	"fmt"
	"github.com/neo4j/neo4j-go-driver/v4/neo4j"
)

func main() {
	config := func(conf *neo4j.Config) {
		//conf.Encrypted = false                         // 启用 TLS
		//conf.TLSCertFile = "/path/to/certificate.crt" // 设置 TLS 证书文件路径
		//conf.TLSKeyFile = "/path/to/private.key"      // 设置 TLS 私钥文件路径
		//conf.TLSCAFile = "/path/to/ca.crt"            // 设置 TLS CA 证书文件路径
	}

	// 创建驱动程序
	driver, err := neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "123456", ""), config)
	if err != nil {
		// 处理错误
	}
	defer driver.Close()
	session := driver.NewSession(neo4j.SessionConfig{})
	defer session.Close()

	cyhperStr := `CREATE (n:city {name: $name})` //创建节点
	//建立关系
	cyhperStr2 := `MATCH (n:city {name: $name}),(k:area {name: "河南省"})
CREATE (n)-[:属于]->(k)`
	nameList := []string{"郑州市", "洛阳市", "开封市", "新乡市", "平顶山市", "焦作市", "安阳市", "鹤壁市", "漯河市", "南阳市", "信阳市", "周口市", "商丘市", "许昌市", "三门峡市", "驻马店市", "濮阳市"}

	for _, name := range nameList {
		//创建节点
		_, err := session.WriteTransaction(func(tx neo4j.Transaction) (interface{}, error) {
			result, err := tx.Run(cyhperStr, map[string]interface{}{
				"name": name,
			})
			if err != nil {
				return nil, err
			}

			return result, nil
		})
		if err != nil {
			// 处理错误
			fmt.Println("err:", err)
			return
		}

		//建立关系
		_, err = session.WriteTransaction(func(tx neo4j.Transaction) (interface{}, error) {
			result, err := tx.Run(cyhperStr2, map[string]interface{}{
				"name": name,
			})
			if err != nil {
				return nil, err
			}

			return result, nil
		})
		if err != nil {
			// 处理错误
			fmt.Println("err:", err)
			return
		}
	}
}