go实现dgraph的各种操作

import "github.com/dgraph-io/dgo"
import "github.com/dgraph-io/dgo/protos/api"
import "google.golang.org/grpc"

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

初始化Node
添加Node
查询数据库
为数据库添加Edge , 即添加predicate <朋友>
更新数据库
删除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 \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)
}

可以看到结果如下:

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 \n",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/