go实现dgraph的各种操作

go实现dgraph的各种操作

import "github.com/dgraph-io/dgo"

import "github.com/dgraph-io/dgo/protos/api"

import "google.golang.org/grpc"

我在这篇博客将会做以下的工作:

1. 初始化Node
2. 添加Node
3. 查询数据库
4. 为数据库添加Edge , 即 添加predicate<朋友>
5. 更新数据库
6. 删除Node

之前我已经实现了用dgraph的http客户端实现 dgraph 的各种操作, 但是在 go 客户端实现和 http 客户端实现还是存在着比较大的区别. 因此, 我就写了这篇博客用于记录.

哦, 对了, 另外还有一个关键就是, 在我写这篇博客的时候 dgraph 在GODOC和GOWalker的文档都还没补全, 有很多方法都还只是写了个名, 甚至都没介绍, 对新手非常不友好.

初始化数据库

此处, 我将创建五个用户作为基础数据库

初始化Person的结构体, 表的属性从中也可以看出

type Person struct{
	Uid		string	`json:"uid,omitempty"`
	Name		string	`json:"name,omitempty"`
	From		string	`json:"from,omitempty"`
	NameOFcn	string	`json:"nameOFcn,omitempty"`
	NameOFjp	string	`json:"nameOFjp,omitempty"`
	NameOFen	string	`json:"nameOFen,omitempty"`
	Age		int	`json:"age,omitempty"`
	Friend		[]Person `json:"friend,omitempty"`
}

插入五个人的数据

var (
	dgraph = flag.String("d", "127.0.0.1:9080", "Dgraph server address")
)

func main() {
	flag.Parse()
	conn, err := grpc.Dial(*dgraph, grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	dg := dgo.NewDgraphClient(api.NewDgraphClient(conn))

	p1 := Person{
		Name: "wangha",
		Age: 17,
		From: "China",
		NameOFen: "wangha",
		NameOFcn: "王哈",
		NameOFjp: "王ハ",
	}
	p2 := Person{
		Name: "chenchao",
		Age: 22,
		From: "China",
		NameOFen: "ChaoChen",
		NameOFcn: "陈超",
	}
	p3 := Person{
		Name: "xhe",
		Age: 18,
		From: "Japan",
		NameOFen: "wanghe",
		NameOFcn: "x鹤",
	}
	p4 := Person{
		Name: "changyang",
		Age: 19,
		From: "England",
		NameOFcn: "常飏",
	}
	p5 := Person{
		Name: "yetao",
		Age: 18,
		From: "Russian",
		NameOFen: "TaoYe",
		NameOFcn: "叶掏",
	}

	op := &api.Operation{}
	op.Schema = `
		name: string .
		age: int .
		from: string .
		nameOFcn: string @index(term) .
		nameOFjp: string @index(term) .
		nameOFen: string @index(term) .
	`

	ctx := context.Background()
	if err := dg.Alter(ctx, op); err != nil {
		log.Fatal(err)
	}

	mu := &api.Mutation{
		CommitNow: true,
	}

	var p = [5]Person{p1,p2,p3,p4,p5}

	for _,x := range p {
		pb, err := json.Marshal(x)
		if err != nil {
			log.Println(err)
		}
		mu.SetJson = pb
		_,err = dg.NewTxn().Mutate(ctx, mu)
		if err != nil {
			log.Println(err)
		}
	}
}

我们可以从http客户端查看验证是否插入成功

可以看出, 插入成功了

添加Node

此处新注册了一位朋友, 我们需要将他添加到 dgprah 中

和前面的步骤基本一样, 只是少了初始化 schema 的步骤

func main() {
	flag.Parse()
	conn, err := grpc.Dial(*dgraph, grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	dg := dgo.NewDgraphClient(api.NewDgraphClient(conn))

	ctx := context.Background()

	mu := &api.Mutation{
		CommitNow: true,
	}

	type arrays struct{
		Uids	[]Person `json:"info"`
	}

	t := Person{
		Name : "yaozhao",
		Age : 24,
		From : "M78Star",
		NameOFcn : "姚X",
		NameOFjp : "姚飞机",
		NameOFen : "ZhaoYao",
	}

	pb, err := json.Marshal(t)
	if err != nil {
		log.Println(err)
	}
	mu.SetJson = pb

	assign,err := dg.NewTxn().Mutate(ctx,mu)
	if err != nil{
		log.Println(err)
	}
	fmt.Printf("assign: %v \n",assign)
}

查询

此时,我们查询有关于Name="yaozhao"的信息

func main() {
	flag.Parse()
	conn, err := grpc.Dial(*dgraph, grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	dg := dgo.NewDgraphClient(api.NewDgraphClient(conn))
	ctx := context.Background()

	vars := make(map[string]string)
	vars["$enname"] = "ZhaoYao"
	q := `query wanghainfo($enname: string){
		info(func: eq(nameOFen, $enname)){
			uid
			expand(_all_)
		}
	}`

	resp, err := dg.NewTxn().QueryWithVars(ctx,q,vars)
	if err != nil {
		log.Println(err)
	}

	type arrays struct{
		Uids	[]Person `json:"info"`
	}

	var r arrays

	err = json.Unmarshal(resp.Json, &r)
	if err != nil{
		log.Println(err)
	}

	log.Println(string(resp.Json))
	log.Println(r.Uids[0].Uid)
}

可以看到结果如下:

添加Edge: predicate<friend>

我在 json 格式进行Mutate时, 没有找到相关的添加Edge的方法, 因此我改为用NQuad格式.

NQuad介绍: RDF/NQuad

func main() {
	flag.Parse()
	conn, err := grpc.Dial(*dgraph, grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	dg := dgo.NewDgraphClient(api.NewDgraphClient(conn))

	ctx := context.Background()

	mu := &api.Mutation{
		CommitNow: true,
	}

	type arrays struct{
		Uids	[]Person `json:"info"`
	}

	var1 := make(map[string]string)
	var1["$enname"] = "wangha"
	q1 := `query wanghainfo($enname: string){
		info(func: eq(nameOFen, $enname)){
			uid
		}
	}`

	resp, err := dg.NewTxn().QueryWithVars(ctx,q1,var1)
	if err != nil {
		log.Println(err)
	}

	var r1 arrays
	var r2 arrays

	err = json.Unmarshal(resp.Json, &r1)
	if err != nil{
		log.Println(err)
	}
	Uid_wangha := r1.Uids[0].Uid

	var1["$enname"] = "TaoYe"
        q2 := `query wanghainfo($enname: string){
                info(func: eq(nameOFen, $enname)){
                        uid
                }
        }`

	resp, err = dg.NewTxn().QueryWithVars(ctx,q2,var1)
	if err != nil{
		log.Println(err)
	}

	err = json.Unmarshal(resp.Json, &r2)
	if err != nil{
		log.Println(err)
	}
	Uid_TaoYe := r2.Uids[0].Uid

	t :=fmt.Sprintf("<%s> <friend> <%s> .",Uid_wangha,Uid_TaoYe)
	mu.SetNquads = []byte(t)

	_,err = dg.NewTxn().Mutate(ctx,mu)
	if err != nil{
		log.Println(err)
	}
}

验证:

更新数据

若在此时, 我发现我的数据弄错了

用户nameOFen="ZhaoYao"的用户age实际应该为20, 此时, 同样是用NQuad来更新数据

func main() {
	flag.Parse()
	conn, err := grpc.Dial(*dgraph, grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	dg := dgo.NewDgraphClient(api.NewDgraphClient(conn))

	ctx := context.Background()

	mu := &api.Mutation{
		CommitNow: true,
	}

	type arrays struct{
		Uids	[]Person `json:"info"`
	}

	var1 := make(map[string]string)
	var1["$enname"] = "ZhaoYao"
	q1 := `query wanghainfo($enname: string){
		info(func: eq(nameOFen, $enname)){
			uid
		}
	}`

	resp, err := dg.NewTxn().QueryWithVars(ctx,q1,var1)
	if err != nil {
		log.Println(err)
	}

	var r1 arrays

	err = json.Unmarshal(resp.Json, &r1)
	if err != nil{
		log.Println(err)
	}
	Uid_wangha := r1.Uids[0].Uid
	log.Println(Uid_wangha)

	t := fmt.Sprintf("<%s> <age> \"%s\" .",Uid_wangha,"20")
	mu.SetNquads = []byte(t)

	assign,err := dg.NewTxn().Mutate(ctx,mu)
	if err != nil{
		log.Println(err)
	}
	fmt.Printf("assign: %v",assign)
}

可以看到结果:

更新成功

删除用户

删除用户时, dgraph规定了无法删除Uid <subject> , 只能删除<predicate>和<object>

使用了&api.Mutation内规定的方法去删除

func main() {
	flag.Parse()
	conn, err := grpc.Dial(*dgraph, grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	dg := dgo.NewDgraphClient(api.NewDgraphClient(conn))
	ctx := context.Background()

	vars := make(map[string]string)
	vars["$enname"] = "ZhaoYao"
	q := `query wanghainfo($enname: string){
		info(func: eq(nameOFen, $enname)){
			uid
		}
	}`

	resp, err := dg.NewTxn().QueryWithVars(ctx,q,vars)
	if err != nil {
		log.Println(err)
	}

	type arrays struct{
		Uids	[]Person `json:"info"`
	}

	var r arrays

	err = json.Unmarshal(resp.Json, &r)
	if err != nil{
		log.Println(err)
	}

	log.Println(string(resp.Json))
	log.Println(r.Uids[0].Uid)

	d := map[string]string{"uid":string(r.Uids[0].Uid)}
	pb, err := json.Marshal(d)

	mu := &api.Mutation{
		CommitNow: true,
		DeleteJson: pb,
	}

	assign,err := dg.NewTxn().Mutate(ctx, mu)
	if err != nil{
		log.Println(err)
	}
	fmt.Printf("assign: %v \n",assign)
}

再次查询, 数据已经消失

写在最后

dgraph 是一个非常强的分布式 NoSql , 想弄懂了真的得看很多遍技术文档

以下链接可能在你学习的时候会有所帮助

Mutate : https://docs.dgraph.io/mutations/

Query : https://docs.dgraph.io/query-language/

Client : https://docs.dgraph.io/clients/

Dgo : https://gowalker.org/github.com/dgraph-io/dgo

Api : https://gowalker.org/github.com/dgraph-io/dgo/protos/api#Assigned

Grpc : https://godoc.org/google.golang.org/grpc

RDF : https://www.w3.org/TR/n-quads/