[Go语言] Go 在 MongoDB 中常用查询与修改的操作

type User struct {
  Id_ bson.ObjectId `bson:"_id"`
  Name string `bson:"name"`
  Age int `bson:"age"`
  JoinedAt time.Time `bson:"joined_at"`
  Interests []string `bson:"interests"`
  Num []int `bson:"num"`
}

var users []User
c.Find(nil).All(&users)

id := "5204af979955496907000001"
objectId := bson.ObjectIdHex(id)
user := new(User)
c.Find(bson.M{"_id": objectId}).One(&user)

c.FindId(objectId).One(&user)

=($eq)
c.Find(bson.M{"name": "Jimmy Kuu"}).All(&users)
!=($ne)
c.Find(bson.M{"name": bson.M{"$ne": "Jimmy Kuu"}}).All(&users)
>($gt)
c.Find(bson.M{"age": bson.M{"$gt": 32}}).All(&users)
<($lt)
c.Find(bson.M{"age": bson.M{"$lt": 32}}).All(&users)
>=($gte)
c.Find(bson.M{"age": bson.M{"$gte": 33}}).All(&users)
<=($lte)
c.Find(bson.M{"age": bson.M{"$lte": 31}}).All(&users)
in($in)
c.Find(bson.M{"name": bson.M{"$in": []string{"Jimmy Kuu", "Tracy Yu"}}}).All(&users)

and($and)
c.Find(bson.M{"name": "Jimmy Kuu", "age": 33}).All(&users)
or($or)
c.Find(bson.M{"$or": []bson.M{bson.M{"name": "Jimmy Kuu"}, bson.M{"age": 31}}}).All(&users)

func (c *Collection) Update(selector interface{}, change interface{}) error

//修改字段的值
c.Update(
  bson.M{"_id": bson.ObjectIdHex("5204af979955496907000001")},
  bson.M{"$set": bson.M{ "name": "Jimmy Gu", "age": 34 }}
)

//字段增加值
c.Update(
  bson.M{"_id": bson.ObjectIdHex("5204af979955496907000001")},
  bson.M{"$inc": bson.M{ "age": -1 }}
)
//字段Num数组第三个数增加值
c.Update(
  bson.M{"_id": bson.ObjectIdHex("5204af979955496907000001")},
  bson.M{"$inc": bson.M{ "Num." + strconv.Itoa(2): 1 }})

//从数组中增加一个元素
c.Update(
  bson.M{"_id": bson.ObjectIdHex("5204af979955496907000001")},
  bson.M{"$push": bson.M{ "interests": "Golang" }}
)

//从数组中删除一个元素
c.Update(
  bson.M{"_id": bson.ObjectIdHex("5204af979955496907000001")},
  bson.M{"$pull": bson.M{ "interests": "Golang" }}
)

c.Remove(bson.M{"name": "Jimmy Kuu"})

func (c *Collection) Find(query interface{}) *Query

type M map[string]interface{}

package main
 
import (
   "fmt"
 
   "gopkg.in/mgo.v2"
   "gopkg.in/mgo.v2/bson"
)
 
// get mongodb db
func getDB() *mgo.Database {
   session, err := mgo.Dial( "172.16.27.134:10001" )
   if err != nil {
     panic(err)
   }
 
   session.SetMode(mgo.Monotonic, true)
   db := session.DB( "test" )
   return db
}

func findOne() {
   db := getDB()
 
   c := db.C( "user" )
 
   // 用struct接收,一般情况下都会这样处理
   type User struct {
     Name string  "bson:`name`"
     Age  int   "bson:`age`"
   }
   user := User{}
   err := c.Find(bson.M{ "name" :  "Tom" }).One(&user)
   if err != nil {
     panic(err)
   }
   fmt.Println(user)
   // output: {Tom 20}
 
   // 用bson.M结构接收，当你不了解返回的数据结构格式时，可以用这个先查看，然后再定义struct格式
   // 在处理mongodb组合查询时，经常这么干
   result := bson.M{}
   err = c.Find(nil).One(&result)
   if err != nil {
     panic(err)
   }
   fmt.Println(result)
   // output: map[_id:ObjectIdHex("56fdce98189df8759fd61e5b") name:Tom age:20]
 
}

func findMuit() {
   db := getDB()
 
   c := db.C( "user" )
 
   // 使用All方法，一次性消耗较多内存，如果数据较多，可以考虑使用迭代器
   type User struct {
     Id   bson.ObjectId `bson: "_id,omitempty" `
     Name string     "bson:`name`"
     Age  int      "bson:`age`"
   }
   var users []User
   err := c.Find(nil).All(&users)
   if err != nil {
     panic(err)
   }
   fmt.Println(users)
   // output: [{ObjectIdHex("56fdce98189df8759fd61e5b") Tom 20}...]
 
   // 使用迭代器获取数据可以避免一次占用较大内存
   var user User
   iter := c.Find(nil).Iter()
   for iter.Next(&user) {
     fmt.Println(user)
   }
   // output:
   // {ObjectIdHex("56fdce98189df8759fd61e5b") Tom 20}
   // {ObjectIdHex("56fdce98189df8759fd61e5c") Tom 20}
   // ...
}

func (q *Query) Select(selector interface{}) *Query

func findField() {
   db := getDB()
 
   c := db.C( "user" )
 
   // 只读取name字段
   type User struct {
     Name string  "bson:`name`"
   }
   var users []User
   err := c.Find(bson.M{}).Select(bson.M{ "name" :  1 }).All(&users)
   if err != nil {
     panic(err)
   }
   fmt.Println(users)
   // output: [{Tom} {Tom} {Anny}...]
 
   // 只排除_id字段
   type User2 struct {
     Name string  "bson:`name`"
     Age  int   "bson:`age`"
   }
   var users2 []User2
   err = c.Find(bson.M{}).Select(bson.M{ "_id" :  0 }).All(&users2)
   if err != nil {
     panic(err)
   }
   fmt.Println(users2)
   // output: [{Tom 20} {Tom 20} {Anny 28}...]
 
}

func findNesting() {
   db := getDB()
 
   c := db.C( "user" )
 
   // 使用嵌套的struct接收数据
   type User struct {
     Name string  "bson:`name`"
     Age  int   "bson:`age`"
     Toys []struct {
       Name string  "bson:`name`"
     }
   }
   var users User
   // 只查询toys字段存在的
   err := c.Find(bson.M{ "toys" : bson.M{ "$exists" : true}}).One(&users)
   if err != nil {
     panic(err)
   }
   fmt.Println(users)
   // output: {Tom 20 [{dog}]}
}

func count() {
   db := getDB()
 
   c := db.C( "user" )
 
   // 查找表总数
   count, err := c.Count()
   if err != nil {
     panic(err)
   }
   fmt.Println(count)
   // output: 8
 
   // 结合find条件查找
   count, err = c.Find(bson.M{ "name" :  "Tom" }).Count()
   if err != nil {
     panic(err)
   }
   fmt.Println(count)
   // output: 6
 
}

func (q *Query) Sort(fields ...string) *Query

func findSort() {
   db := getDB() 
   c := db.C( "user" ) 
   type User struct {
     Id   bson.ObjectId `bson: "_id,omitempty" `
     Name string     "bson:`name`"
     Age  int      "bson:`age`"
   }
   var users []User
   // 按照age字段降序排列，如果升序去掉横线"-"就可以了
   err := c.Find(nil).Sort( "-age" ).All(&users)
   if err != nil {
     panic(err)
   }
   fmt.Println(users)
   // output:
   // [{ObjectIdHex("56fdce98189df8759fd61e5d") Anny 28} ...]
   // ...
}

func (q *Query) Skip(n int) *Query
func (q *Query) Limit(n int) *Query

func findPage() {
   db := getDB() 
   c := db.C( "user" ) 
   type User struct {
     Id   bson.ObjectId `bson: "_id,omitempty" `
     Name string     "bson:`name`"
     Age  int      "bson:`age`"
   }
   var users []User
   // 表示从偏移位置为2的地方开始取两条记录
   err := c.Find(nil).Sort( "-age" ).Skip( 2 ).Limit( 2 ).All(&users)
   if err != nil {
     panic(err)
   }
   fmt.Println(users)
   // output:
   // [{ObjectIdHex("56fdce98189df8759fd61e5d") Anny 20} ...]
   // ...
}