// CharmEvent returns the most recent event associated with url
// and digest. If the specified event isn't found the error
// ErrUnknownChange will be returned. If digest is empty, any
// digest will match.
func (s *Store) CharmEvent(url *charm.URL, digest string) (*CharmEvent, error) {
// TODO: It'd actually make sense to find the charm event after the
// revision id, but since we don't care about that now, just make sure
// we don't write bad code.
if err := mustLackRevision("CharmEvent", url); err != nil {
return nil, err
}
session := s.session.Copy()
defer session.Close()
events := session.Events()
event := &CharmEvent{Digest: digest}
var query *mgo.Query
if digest == "" {
query = events.Find(bson.D{{"urls", url}})
} else {
query = events.Find(bson.D{{"urls", url}, {"digest", digest}})
}
err := query.Sort("-time").One(&event)
if err == mgo.ErrNotFound {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
return event, nil
}
func (e *Environment) refresh(query *mgo.Query) error {
err := query.One(&e.doc)
if err == mgo.ErrNotFound {
return errors.NotFoundf("environment")
}
return err
}
// 创建一个分页结构体
func NewPagination(query *mgo.Query, url string, prePage int) *Pagination {
p := Pagination{}
p.query = query
p.count, _ = query.Count()
p.prePage = prePage
return &p
}
func usergroupSort(q *mgo.Query, sortFields []string) {
if len(sortFields) > 0 {
q.Sort(sortFields...)
return
}
q.Sort("-_id")
}
func (ctx *DBCtx) CatTree(root bson.ObjectId) []Catergory {
all := []Catergory{}
var query *mgo.Query
if root.Valid() {
query = ctx.catColl.Find(bson.M{"ancestors": root})
} else {
query = ctx.catColl.Find(bson.M{"parent": bson.M{"$exists": false}})
}
query.All(&all)
return all
}
func (qw *QueryWork) Do(c chan<- interface{}) {
customerID := qw.randSource.Int31n(MaxNumCustomers)
cashRegisterID := qw.randSource.Int31n(MaxNumCashRegisters)
price := qw.randSource.Float64()*MaxPrice + float64(customerID)/100.0
// generate a random time since qw.StartTime
// there is likely a better way to do this
since := time.Since(qw.startTime)
sinceInNano := since.Nanoseconds()
var randomTime int64
if sinceInNano > 0 {
randomTime = qw.randSource.Int63n(sinceInNano)
}
timeToQuery := qw.startTime.Add(time.Duration(randomTime))
var query *mgo.Query
if qw.numQueriesSoFar%3 == 0 {
filter := bson.M{"$or": []bson.M{
bson.M{"pr": price, "ts": timeToQuery, "cid": bson.M{"$gte": customerID}},
bson.M{"pr": price, "ts": bson.M{"$gt": timeToQuery}},
bson.M{"pr": bson.M{"$gt": price}}}}
projection := bson.M{"pr": 1, "ts": 1, "cid": 1}
query = qw.coll.Find(filter).Select(projection).Hint("pr", "ts", "cid")
} else if qw.numQueriesSoFar%3 == 1 {
filter := bson.M{"$or": []bson.M{
bson.M{"crid": cashRegisterID, "pr": price, "cid": bson.M{"$gte": customerID}},
bson.M{"crid": cashRegisterID, "pr": bson.M{"$gt": price}},
bson.M{"crid": bson.M{"$gt": cashRegisterID}}}}
projection := bson.M{"crid": 1, "pr": 1, "cid": 1}
query = qw.coll.Find(filter).Select(projection).Hint("crid", "pr", "cid")
} else {
filter := bson.M{"$or": []bson.M{
bson.M{"pr": price, "cid": bson.M{"$gte": customerID}},
bson.M{"pr": bson.M{"$gt": price}}}}
projection := bson.M{"pr": 1, "cid": 1}
query = qw.coll.Find(filter).Select(projection).Hint("pr", "cid")
}
var result bson.M
iter := query.Limit(*queryResultLimit).Iter()
for iter.Next(&result) {
}
qw.numQueriesSoFar++
c <- Result{NumQueries: 1}
}