From 52fcfce8e4fe0b604dfde192691e71ef2af94766 Mon Sep 17 00:00:00 2001 From: vCaesar Date: Sun, 8 Jan 2017 21:22:13 +0800 Subject: [PATCH] Update other mgo --- de/05.6.md | 69 +++++++++++++++++++++++++++------------------------ en/05.6.md | 44 ++++++++++++++++---------------- es/05.6.md | 52 ++++++++++++++++++++------------------ ja/05.6.md | 16 ++++++++---- pt-br/05.6.md | 66 ++++++++++++++++++++++++++---------------------- zh/05.6.md | 44 ++++++++++++++++---------------- 6 files changed, 156 insertions(+), 135 deletions(-) diff --git a/de/05.6.md b/de/05.6.md index bf3bdc0a..930dd1e8 100644 --- a/de/05.6.md +++ b/de/05.6.md @@ -66,44 +66,49 @@ The best driver for mongoDB is called `mgo`, and it is possible that it will be Here is the example: +```Go + package main - + import ( - "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "fmt" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" + "log" ) - + type Person struct { - Name string - Phone string - } - - func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() - - session.SetMode(mgo.Monotonic, true) - - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - panic(err) - } - - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - panic(err) - } - - fmt.Println("Phone:", result.Phone) + Name string + Phone string } + func main() { + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() + + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) + + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } + + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } + + fmt.Println("Phone:", result.Phone) + } + +``` We can see that there are no big differences when it comes to operating on mgo or beedb databases; they are both based on structs. This is the Go way of doing things. ## Links diff --git a/en/05.6.md b/en/05.6.md index 0fa888c6..4f83df2c 100644 --- a/en/05.6.md +++ b/en/05.6.md @@ -155,40 +155,40 @@ Here is the example: import ( "fmt" - "log" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" + "log" ) type Person struct { - Name string - Phone string + Name string + Phone string } func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() - // Optional. Switch the session to a monotonic behavior. - session.SetMode(mgo.Monotonic, true) + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - log.Fatal(err) - } + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - log.Fatal(err) - } + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } - fmt.Println("Phone:", result.Phone) + fmt.Println("Phone:", result.Phone) } ``` diff --git a/es/05.6.md b/es/05.6.md index b69f6da8..3a1096ba 100644 --- a/es/05.6.md +++ b/es/05.6.md @@ -65,44 +65,48 @@ Figura 5.1 MongoDB comparada con Mysql El mejor manejador para mongoDB es llamado `mgo`, y es posible que se incluya en la librería estándar en el futuro. Aquí está un ejemplo -``` +```Go + package main import ( - "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "fmt" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" + "log" ) type Person struct { - Name string - Phone string + Name string + Phone string } func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() - session.SetMode(mgo.Monotonic, true) + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - panic(err) - } + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - panic(err) - } + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } - fmt.Println("Phone:", result.Phone) + fmt.Println("Phone:", result.Phone) } + ``` Como podemos ver no hay muchas diferencias en lo que respecta a operar con mgo o bases de datos beedb; ambas son basadas en estructuras. Esta es la manera en que Go hace las cosas. diff --git a/ja/05.6.md b/ja/05.6.md index 36c80693..e59e6f4a 100644 --- a/ja/05.6.md +++ b/ja/05.6.md @@ -66,16 +66,19 @@ MongoDBは高性能でオープンソース、モードレスなドキュメン 次にどのようにしてGoからmongoDBを操作するのかご説明します： +```Go + package main import ( "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" + "log" ) type Person struct { - Name string + Name string Phone string } @@ -86,24 +89,27 @@ MongoDBは高性能でオープンソース、モードレスなドキュメン } defer session.Close() + // Optional. Switch the session to a monotonic behavior. session.SetMode(mgo.Monotonic, true) c := session.DB("test").C("people") err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, &Person{"Cla", "+55 53 8402 8510"}) if err != nil { - panic(err) + log.Fatal(err) } result := Person{} err = c.Find(bson.M{"name": "Ale"}).One(&result) if err != nil { - panic(err) + log.Fatal(err) } fmt.Println("Phone:", result.Phone) } +``` + mgoの操作方法とbeedbの操作方法はほとんど似ていることがわかります。どちらもstructに基づいて操作する方法です。これこそがGo Styleです。 diff --git a/pt-br/05.6.md b/pt-br/05.6.md index bf3bdc0a..ab798a70 100644 --- a/pt-br/05.6.md +++ b/pt-br/05.6.md @@ -66,44 +66,50 @@ The best driver for mongoDB is called `mgo`, and it is possible that it will be Here is the example: +```Go + package main - + import ( - "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "fmt" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" + "log" ) - + type Person struct { - Name string - Phone string + Name string + Phone string } - + func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() - - session.SetMode(mgo.Monotonic, true) - - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - panic(err) - } - - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - panic(err) - } - - fmt.Println("Phone:", result.Phone) + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() + + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) + + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } + + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } + + fmt.Println("Phone:", result.Phone) } +``` + We can see that there are no big differences when it comes to operating on mgo or beedb databases; they are both based on structs. This is the Go way of doing things. ## Links diff --git a/zh/05.6.md b/zh/05.6.md index f42032f9..fd913fb6 100644 --- a/zh/05.6.md +++ b/zh/05.6.md @@ -158,40 +158,40 @@ MongoDB是一个高性能，开源，无模式的文档型数据库，是一个 import ( "fmt" - "log" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" + "log" ) type Person struct { - Name string - Phone string + Name string + Phone string } func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() - // Optional. Switch the session to a monotonic behavior. - session.SetMode(mgo.Monotonic, true) + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - log.Fatal(err) - } + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - log.Fatal(err) - } + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } - fmt.Println("Phone:", result.Phone) + fmt.Println("Phone:", result.Phone) } ```