• 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客户端查看验证是否插入成功

    init

    可以看出, 插入成功了

    添加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 
    ",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)
    }
    

    可以看到结果如下:

    queryuid

    添加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)
    	}
    }
    

    验证:

    addfriend

    更新数据

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

    用户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)
    }
    

    可以看到结果:

    update

    更新成功

    删除用户

    删除用户时, 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 
    ",assign)
    }
    

    再次查询, 数据已经消失

    delete

    写在最后

    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/

  • 相关阅读:
    .NET基础知识-类型、方法与继承
    .NET基础知识-string、StringBuilder、字符串操作
    .NET基础知识-装箱与拆箱
    .NET基础知识-值类型与引用类型
    Python之多进程、多线程、协程、同步/异步、并发/并行
    设计模式之工厂模式
    设计模式之单例模式
    python模块之logging
    python模块之hashlib
    python模块之pickle&json&shelve
  • 原文地址:https://www.cnblogs.com/wangha/p/10488888.html
Copyright © 2020-2023  润新知