Example #1
0
// 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
}
Example #2
0
func (e *Environment) refresh(query *mgo.Query) error {
	err := query.One(&e.doc)
	if err == mgo.ErrNotFound {
		return errors.NotFoundf("environment")
	}
	return err
}
Example #3
0
// 创建一个分页结构体
func NewPagination(query *mgo.Query, url string, prePage int) *Pagination {
	p := Pagination{}
	p.query = query
	p.count, _ = query.Count()
	p.prePage = prePage
	return &p
}
Example #4
0
func usergroupSort(q *mgo.Query, sortFields []string) {
	if len(sortFields) > 0 {
		q.Sort(sortFields...)
		return
	}

	q.Sort("-_id")
}
Example #5
0
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
}
Example #6
0
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}
}