Golang datastore.Query类代码示例

func queryPackages(c appengine.Context, cacheKey string, query *datastore.Query) ([]*Package, error) {
	var pkgs []*Package
	item, err := cacheGet(c, cacheKey, &pkgs)
	if err == memcache.ErrCacheMiss {
		keys, err := query.GetAll(c, &pkgs)
		if err != nil {
			return nil, err
		}
		for i := range keys {
			importPath := keys[i].StringID()
			if importPath[0] == '/' {
				// Standard packages start with "/"
				importPath = importPath[1:]
			}
			pkgs[i].ImportPath = importPath
		}
		item.Expiration = time.Hour
		item.Object = pkgs
		if err := cacheSafeSet(c, item); err != nil {
			return nil, err
		}
	} else if err != nil {
		return nil, err
	}
	return pkgs, nil
}

/**
 * データストアから指定された単語を削除する
 * API
 */
func delete(w http.ResponseWriter, r *http.Request) {
	var c appengine.Context
	var u *user.User
	var query *datastore.Query
	var word string
	var iterator *datastore.Iterator
	var key *datastore.Key
	var err error
	var entity Entity

	word = r.FormValue("word")
	if word == "" {
		return
	}

	c = appengine.NewContext(r)
	u = user.Current(c)
	query = datastore.NewQuery("words").Filter("UserID =", u.ID).Filter("Word =", word)
	iterator = query.Run(c)

	for {
		key, err = iterator.Next(&entity)
		if err != nil {
			break
		}
		err = datastore.Delete(c, key)
		Check(c, err)
	}
}

func GetAllKeys(c appengine.Context, q *ds.Query, limit int) ([]*ds.Key, ds.Cursor, bool, error) {
	it := q.KeysOnly().Limit(limit + 1).Run(c)

	keys := make([]*ds.Key, 0, limit)
	hasMore := true
	for i := 0; i < limit; i++ {
		key, err := it.Next(nil)
		if err == ds.Done {
			hasMore = false
			break
		} else if err != nil {
			return nil, ds.Cursor{}, false, err
		}
		keys = append(keys, key)
	}

	cursor, _ := it.Cursor()
	if hasMore {
		if _, err := it.Next(nil); err != nil {
			hasMore = false
		}
	}

	return keys, cursor, hasMore, nil
}

// DelQuery will delete (from datastore and memcache) all entities of type src that matches q.
// src must be a pointer to a struct type.
func DelQuery(c PersistenceContext, src interface{}, q *datastore.Query) (err error) {
	var dataIds []*datastore.Key
	results := reflect.New(reflect.SliceOf(reflect.TypeOf(src).Elem()))
	dataIds, err = q.GetAll(c, results.Interface())
	if err = FilterOkErrors(err); err != nil {
		return
	}
	memcacheKeys := []string{}
	var el reflect.Value
	resultsSlice := results.Elem()
	for index, dataId := range dataIds {
		el = resultsSlice.Index(index)
		var k key.Key
		if k, err = gaekey.FromGAE(dataId); err != nil {
			return
		}
		el.FieldByName("Id").Set(reflect.ValueOf(k))
		if _, err = MemcacheKeys(c, el.Addr().Interface(), &memcacheKeys); err != nil {
			return
		}
		if err = runProcess(c, el.Addr().Interface(), BeforeDeleteName, nil); err != nil {
			return
		}
	}
	if err = datastore.DeleteMulti(c, dataIds); err != nil {
		return
	}
	for index, _ := range dataIds {
		el = resultsSlice.Index(index)
		if err = runProcess(c, el.Addr().Interface(), AfterDeleteName, nil); err != nil {
			return
		}
	}
	return memcache.Del(c, memcacheKeys...)
}

// This kind of iterator expects to last more than 60s, which is when a regular datastore
// iterator will timeout (it thinks its view of the world is too stale)
// Instead, we just grab all the keys up front, and than instantiate them one at a time.
func (db FlightDB) LongIterWith(q *datastore.Query, flightProcFunc func(*f.Flight)) error {
	keys, err := q.KeysOnly().GetAll(db.C, nil)
	if err != nil {
		return err
	}

	for _, key := range keys {
		blob := f.FrozenFlight{}

		if err := datastore.Get(db.C, key, &blob); err != nil {
			return err
		}

		if flight, err := blob.Thaw(); err != nil {
			return err
		} else {
			//flight.EnterUTC,flight.LeaveUTC = flight.Track.TimesInBox(sfo.KBoxSnarfingCatchment)
			flight.SetDatastoreKey(key.Encode())

			flightProcFunc(flight)
		}
	}

	return nil
}

func getRadarsFromQuery(
	c appengine.Context,
	query *datastore.Query,
	limit int) (radars []Radar, cursor_out string, err error) {

	radars = make([]Radar, 0, limit)
	count := 0
	iterator := query.Run(c)
	for {
		var radar Radar
		_, err := iterator.Next(&radar)
		if err == datastore.Done {
			return radars, "", nil
		} else if err != nil {
			c.Errorf("Radar iterator error: %v", err)
			continue
		} else {
			radars = append(radars, radar)
		}
		count = count + 1
		if count == limit {
			break
		}
	}
	// in case there are more radars, continue using a cursor based on the current position
	if cursor, err := iterator.Cursor(); err == nil {
		cursor_out = cursor.String()
	}
	return radars, cursor_out, nil
}

func ExecuteQuery(c appengine.Context, q *datastore.Query, start int, limit int, filter func(Post) bool, out chan<- Post, errout chan<- error) {

	defer close(out)
	defer close(errout)

	for t, i := q.Run(c), 0; ; i++ {
		if ((start < 0) || (limit < 0)) || (i < (start + limit)) {
			var x Post
			// key, err := t.Next(&x)
			_, err := t.Next(&x)

			if err == datastore.Done {
				return
			}
			if err != nil {
				errout <- err
				return
			}

			if !filter(x) {
				i--
				continue
			}

			if i < start {
				continue
			}

			out <- x
		} else {
			break
		}
	}
}

//MultiQuery executes given query and returns slice of all the entities it returns, with their keys set.
func MultiQuery(c appengine.Context, typ reflect.Type, kind string, query *datastore.Query) (ms interface{}, err error) {
	is := reflect.MakeSlice(reflect.SliceOf(reflect.PtrTo(typ)), 0, 0)

	iter := query.Run(c)

	for {
		val := reflect.New(typ)
		var key *datastore.Key
		key, err = iter.Next(val.Interface())
		if err != nil {
			if err == datastore.Done {
				err = nil
				val.MethodByName("SetKey").Call([]reflect.Value{reflect.ValueOf(key)})
				reflect.Append(is, val)
				break
			}
			return
		}
		val.MethodByName("SetKey").Call([]reflect.Value{reflect.ValueOf(key)})
		is = reflect.Append(is, val)
	}

	ms = is.Interface()

	return
}

func GreaterThanEqualQuery(query *datastore.Query, values url.Values, s string) *datastore.Query {
	if len(values[s]) != 0 {
		columnName := strings.TrimRight(strings.ToUpper(s[:1])+s[1:], "From")
		query = query.Filter(columnName+">=", ToInt(values[s][0])).Order(columnName)
	}
	return query
}

func (db FlightDB) lookupByQuery(q *datastore.Query, memKey string) ([]f.Flight, error) {

	if db.Memcache && memKey != "" {
		if flights, found := db.flightsFromShardedMemcache(memKey); found {
			return flights, nil
		}
	}

	fflights := []f.FrozenFlight{}
	//db.C.Infof(" #--- actually going to datastore ...")
	keys, err := q.GetAll(db.C, &fflights)
	if err != nil {
		return nil, err
	}

	flights := []f.Flight{}
	for i, fflight := range fflights {
		if flight, err := fflight.Thaw(); err != nil {
			return nil, err
		} else {
			flight.EnterUTC, flight.LeaveUTC = flight.Track.TimesInBox(sfo.KBoxSnarfingCatchment)
			flight.SetDatastoreKey(keys[i].Encode())
			flights = append(flights, *flight)
		}
	}

	if db.Memcache && memKey != "" {
		db.flightsToShardedMemcache(memKey, flights)
	}

	return flights, nil
}

func (fdb FlightDB) NewIter(q *datastore.Query) *FlightIterator {
	fi := FlightIterator{
		C:     fdb.C,
		Query: q,
		Iter:  q.Run(fdb.C),
	}
	return &fi
}

/* Query the datastore.
 * TODO: Use memcache.
 *
 * @param context for this particular appengine session
 * @param key datastore key for the object to be retrieved
 * @param object the object to be made persistent
 * @param error message to be printed to the log / user in case of error
 * @return a list of keys returned by the query and errors generated by the query (if there are any)
 */
func query(context appengine.Context, query *datastore.Query, objects interface{}, error string) ([]*datastore.Key, os.Error) {
	keys, err := query.GetAll(context, objects)
	if err != nil {
		log.Println(error + err.String())
		return nil, err
	}
	return keys, nil
}

func (cdb ComplaintDB) NewIter(q *datastore.Query) *ComplaintIterator {
	ci := ComplaintIterator{
		C:     cdb.C,
		Query: q,
		Iter:  q.Run(cdb.C),
	}
	return &ci
}

// firstMatch executes the query q and loads the first entity into v.
func firstMatch(c appengine.Context, q *datastore.Query, v interface{}) error {
	t := q.Limit(1).Run(c)
	_, err := t.Next(v)
	if err == datastore.Done {
		err = datastore.ErrNoSuchEntity
	}
	return err
}

func (db FlightDB) countByQuery(q *datastore.Query) (int, error) {
	q2 := q.KeysOnly()

	keys, err := q2.GetAll(db.C, nil)
	if err != nil {
		return 0, err
	}

	return len(keys), nil
}