lostecho/build-web-application-with-golang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update other mgo

Browse Source
This commit is contained in:
vCaesar
2017-01-08 21:22:13 +08:00
parent 4deec35035
commit 52fcfce8e4
6 changed files with 156 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
de/05.6.md
View File

@@ -66,44 +66,49 @@ The best driver for mongoDB is called `mgo`, and it is possible that it will be
Here is the example: Here is the example:
```Go
package main package main
import ( import (
"fmt" "fmt"
"labix.org/v2/mgo" "gopkg.in/mgo.v2"
"labix.org/v2/mgo/bson" "gopkg.in/mgo.v2/bson"
"log"
) )
type Person struct { type Person struct {
Name string Name string
Phone 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)
} }
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. 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 ## Links

44
en/05.6.md
View File

@@ -155,40 +155,40 @@ Here is the example:
import ( import (
"fmt" "fmt"
"log"
"gopkg.in/mgo.v2" "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson" "gopkg.in/mgo.v2/bson"
"log"
) )
type Person struct { type Person struct {
Name string Name string
Phone string Phone string
} }
func main() { func main() {
session, err := mgo.Dial("server1.example.com,server2.example.com") session, err := mgo.Dial("server1.example.com,server2.example.com")
if err != nil { if err != nil {
panic(err) panic(err)
} }
defer session.Close() defer session.Close()
// Optional. Switch the session to a monotonic behavior. // Optional. Switch the session to a monotonic behavior.
session.SetMode(mgo.Monotonic, true) session.SetMode(mgo.Monotonic, true)
c := session.DB("test").C("people") c := session.DB("test").C("people")
err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
&Person{"Cla", "+55 53 8402 8510"}) &Person{"Cla", "+55 53 8402 8510"})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
result := Person{} result := Person{}
err = c.Find(bson.M{"name": "Ale"}).One(&result) err = c.Find(bson.M{"name": "Ale"}).One(&result)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
fmt.Println("Phone:", result.Phone) fmt.Println("Phone:", result.Phone)
} }
``` ```

52
es/05.6.md
View File

@@ -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. 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 Aquí está un ejemplo
``` ```Go
package main package main
import ( import (
"fmt" "fmt"
"labix.org/v2/mgo" "gopkg.in/mgo.v2"
"labix.org/v2/mgo/bson" "gopkg.in/mgo.v2/bson"
"log"
) )
type Person struct { type Person struct {
Name string Name string
Phone string Phone string
} }
func main() { func main() {
session, err := mgo.Dial("server1.example.com,server2.example.com") session, err := mgo.Dial("server1.example.com,server2.example.com")
if err != nil { if err != nil {
panic(err) panic(err)
} }
defer session.Close() 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") c := session.DB("test").C("people")
err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
&Person{"Cla", "+55 53 8402 8510"}) &Person{"Cla", "+55 53 8402 8510"})
if err != nil { if err != nil {
panic(err) log.Fatal(err)
} }
result := Person{} result := Person{}
err = c.Find(bson.M{"name": "Ale"}).One(&result) err = c.Find(bson.M{"name": "Ale"}).One(&result)
if err != nil { if err != nil {
panic(err) 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. 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.

16
ja/05.6.md
View File

@@ -66,16 +66,19 @@ MongoDBは高性能でオープンソース、モードレスなドキュメン
次にどのようにしてGoからmongoDBを操作するのかご説明します： 次にどのようにしてGoからmongoDBを操作するのかご説明します：
```Go
package main package main
import ( import (
"fmt" "fmt"
"labix.org/v2/mgo" "gopkg.in/mgo.v2"
"labix.org/v2/mgo/bson" "gopkg.in/mgo.v2/bson"
"log"
) )
type Person struct { type Person struct {
Name string Name string
Phone string Phone string
} }
@@ -86,24 +89,27 @@ MongoDBは高性能でオープンソース、モードレスなドキュメン
} }
defer session.Close() defer session.Close()
// Optional. Switch the session to a monotonic behavior.
session.SetMode(mgo.Monotonic, true) session.SetMode(mgo.Monotonic, true)
c := session.DB("test").C("people") c := session.DB("test").C("people")
err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
&Person{"Cla", "+55 53 8402 8510"}) &Person{"Cla", "+55 53 8402 8510"})
if err != nil { if err != nil {
panic(err) log.Fatal(err)
} }
result := Person{} result := Person{}
err = c.Find(bson.M{"name": "Ale"}).One(&result) err = c.Find(bson.M{"name": "Ale"}).One(&result)
if err != nil { if err != nil {
panic(err) log.Fatal(err)
} }
fmt.Println("Phone:", result.Phone) fmt.Println("Phone:", result.Phone)
} }
```
mgoの操作方法とbeedbの操作方法はほとんど似ていることがわかります。どちらもstructに基づいて操作する方法です。これこそがGo Styleです。 mgoの操作方法とbeedbの操作方法はほとんど似ていることがわかります。どちらもstructに基づいて操作する方法です。これこそがGo Styleです。

66
pt-br/05.6.md
View File

@@ -66,44 +66,50 @@ The best driver for mongoDB is called `mgo`, and it is possible that it will be
Here is the example: Here is the example:
```Go
package main package main
import ( import (
"fmt" "fmt"
"labix.org/v2/mgo" "gopkg.in/mgo.v2"
"labix.org/v2/mgo/bson" "gopkg.in/mgo.v2/bson"
"log"
) )
type Person struct { type Person struct {
Name string Name string
Phone string Phone string
} }
func main() { func main() {
session, err := mgo.Dial("server1.example.com,server2.example.com") session, err := mgo.Dial("server1.example.com,server2.example.com")
if err != nil { if err != nil {
panic(err) panic(err)
} }
defer session.Close() 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"}, c := session.DB("test").C("people")
&Person{"Cla", "+55 53 8402 8510"}) err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
if err != nil { &Person{"Cla", "+55 53 8402 8510"})
panic(err) if err != nil {
} log.Fatal(err)
}
result := Person{}
err = c.Find(bson.M{"name": "Ale"}).One(&result) result := Person{}
if err != nil { err = c.Find(bson.M{"name": "Ale"}).One(&result)
panic(err) if err != nil {
} log.Fatal(err)
}
fmt.Println("Phone:", result.Phone)
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. 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 ## Links

44
zh/05.6.md
View File

@@ -158,40 +158,40 @@ MongoDB是一个高性能，开源，无模式的文档型数据库，是一个
import ( import (
"fmt" "fmt"
"log"
"gopkg.in/mgo.v2" "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson" "gopkg.in/mgo.v2/bson"
"log"
) )
type Person struct { type Person struct {
Name string Name string
Phone string Phone string
} }
func main() { func main() {
session, err := mgo.Dial("server1.example.com,server2.example.com") session, err := mgo.Dial("server1.example.com,server2.example.com")
if err != nil { if err != nil {
panic(err) panic(err)
} }
defer session.Close() defer session.Close()
// Optional. Switch the session to a monotonic behavior. // Optional. Switch the session to a monotonic behavior.
session.SetMode(mgo.Monotonic, true) session.SetMode(mgo.Monotonic, true)
c := session.DB("test").C("people") c := session.DB("test").C("people")
err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
&Person{"Cla", "+55 53 8402 8510"}) &Person{"Cla", "+55 53 8402 8510"})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
result := Person{} result := Person{}
err = c.Find(bson.M{"name": "Ale"}).One(&result) err = c.Find(bson.M{"name": "Ale"}).One(&result)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
fmt.Println("Phone:", result.Phone) fmt.Println("Phone:", result.Phone)
} }
``` ```