Golang datastore.GetMulti函数代码示例

func GetGames(c appengine.Context, ids []int) ([]Game, []*datastore.Key, error) {
	c.Infof("ids: %v", ids)
	games := make([]Game, len(ids), len(ids))
	keys := make([]*datastore.Key, len(ids), len(ids))
	for i, value := range ids {
		key, err2 := getKeyForIndex(c, value)
		keys[i] = key
		if err2 != nil {
			c.Infof("Error gettingGameKey: %v", err2)
			return games, keys, err2
		}
	}
	err := datastore.GetMulti(c, keys, games)
	if err != nil {
		c.Infof("Error getting games: %v, keys: %v", err, keys)
		return games, keys, err
	}

	for i, g := range games {
		temp := make([]Round, 5, 5)
		temp2 := g.RoundsJson
		err2 := json.Unmarshal(temp2, &temp)
		if err2 != nil {
			c.Infof("Error converting Json %v", err2)
			return games, nil, err2
		}
		g.Rounds = temp
		games[i] = g
	}
	return games, keys, nil

}

// Retrieves all the in-progress stories for the given author.
func inProgressStories(c appengine.Context, author string) []InProgressStory {

	q := datastore.NewQuery("StoryAuthor").
		Filter("Author =", author).
		KeysOnly()

	keys, err := q.GetAll(c, nil)
	if err != nil {
		panic(&appError{err, "Failed to fetch in-progress story authors", 500})
	}

	storyKeys := make([]*datastore.Key, len(keys))

	for i, key := range keys {
		storyKeys[i] = key.Parent()
	}
	stories := make([]Story, len(keys))
	if err := datastore.GetMulti(c, storyKeys, stories); err != nil {
		panic(&appError{err, "Failed to fetch in-progress stories", 500})
	}
	sort.Sort(byTime(stories))

	inProgress := make([]InProgressStory, len(keys))
	for i, story := range stories {
		inProgress[i] = story.InProgress(author)
		inProgress[i].RewriteAuthors(nameFunc(c))
	}

	return inProgress
}

// listState retrieves the state of every list owned by this user, in the form
// of a map between list ID and its current state.
func listState(c appengine.Context, user *model.User) (out map[string]*string, err error) {
	out = make(map[string]*string)

	// Load current state from memcache, if possible.
	// TODO: ... do this.

	// Try to load the remaining keys from datastore.
	db := make([]model.List, len(user.Sub))
	keys := make([]*datastore.Key, len(user.Sub))
	for i, sub := range user.Sub {
		keys[i] = datastore.NewKey(c, "List", sub, 0, nil)
	}
	err = datastore.GetMulti(c, keys, db)
	if err != nil {
		return
	}
	for i := 0; i < len(db); i++ {
		// TODO: return output even if we see errors.
		state := db[i].State()
		out[db[i].Id] = &state
	}

	// Success!
	return
}

func userHandler(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)
	uu := user.Current(ctx)
	if verifyLogin(ctx, uu, w, r) {
		return
	}
	u := GetUser(ctx, uu.ID)
	if u == nil {
		ctx.Infof("unknown user, going to /start")
		http.Redirect(w, r, "/start", http.StatusSeeOther)
		return
	}

	repos, _, err := newClient(ctx, u.GitHubToken).Repositories.List("", &github.RepositoryListOptions{
		Type: "all",
	})
	if err != nil {
		ctx.Errorf("listing repos: %v", err)
		renderError(w, "Error listing repos")
		return
	}

	type data struct {
		Repo     github.Repository
		Disabled bool
		Branch   string
	}
	d := []data{}

	keys := []*datastore.Key{}
	for _, r := range repos {
		keys = append(keys, datastore.NewKey(ctx, "Repo", *r.FullName, 0, nil))
	}
	repoEntities := make([]Repo, len(keys))
	if err := datastore.GetMulti(ctx, keys, repoEntities); err != nil {
		if me, ok := err.(appengine.MultiError); ok {
			for i, e := range me {
				var disabled = e == nil
				var branch = ""
				if e == nil {
					branch = repoEntities[i].Branch
				}
				d = append(d, data{Repo: repos[i], Disabled: disabled, Branch: branch})
			}
		} else {
			ctx.Errorf("getmulti: %v", err)
			renderError(w, "Error retrieving repos")
			return
		}
	} else {
		// all repos are disabled
		for _, r := range repos {
			d = append(d, data{Repo: r, Disabled: true})
		}
	}

	if err := userTmpl.Execute(w, d); err != nil {
		ctx.Errorf("executing template: %v", err)
	}
}

func recentCommentsHandler(p *PageRequest) (err error) {
	q := datastore.NewQuery("Comment").Order("-Created").Limit(100)
	var comments []Comment
	commentKeys, err := q.GetAll(p.c, &comments)
	// get the radars for each comment
	radarKeys := make([]*datastore.Key, len(comments), len(comments))
	for i, comment := range comments {
		radarKeys[i] = datastore.NewKey(p.c, "Radar", "", comment.RadarNumber, nil)
	}
	radars := make([]Radar, len(comments), len(comments))
	err = datastore.GetMulti(p.c, radarKeys, radars)
	if err != nil {
		return err
	}
	for i, _ := range comments {
		comments[i].Radar = &radars[i]
		comments[i].Key = commentKeys[i]
		comments[i].Number = comments[i].Key.IntID()
	}
	if err == nil {
		p.Set("Comments", comments)
		p.Set("Title", "Recent Comments")
		err = p.Template("templates/comments.html")
		err = p.Template("templates/comment.html")
	}
	return
}

func queueGet(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	userId := r.FormValue("UserId")
	q := datastore.NewQuery("queueplayer").Filter("UserId =", userId).Order("-Timestamp").KeysOnly()
	keys, err := q.GetAll(c, nil)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	gameKeys := make([]*datastore.Key, len(keys))
	for i, k := range keys {
		gameKeys[i] = k.Parent()
	}

	games := make([]Game, len(keys))
	err = datastore.GetMulti(c, gameKeys, games)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	for i, k := range keys {
		games[i].Id = k.Parent().Encode()
	}

	data, err := json.Marshal(games)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(data)
}

// GetMulti is a batch version of Get. Cached values are returned from memcache, uncached values are returned from
// datastore and memcached for next time.
//
// dst must be a []S, []*S, []I or []P, for some struct type S, some interface type I, or some non-interface
// non-pointer type P such that P or *P implements PropertyLoadSaver. If an []I, each element must be a valid
// dst for Get: it must be a struct pointer or implement PropertyLoadSaver.
//
// As a special case, PropertyList is an invalid type for dst, even though a PropertyList is a slice of structs.
// It is treated as invalid to avoid being mistakenly passed when []PropertyList was intended.
func GetMulti(c appengine.Context, key []*datastore.Key, dst interface{}) error {
	if len(key) == 0 {
		return nil
	}
	// check cache
	encodedKeys := encodeKeys(key)
	itemMap, errm := memcache.GetMulti(c, encodedKeys)
	if len(itemMap) != len(key) {
		// TODO benchmark loading all vs loading missing
		// load from datastore
		errd := datastore.GetMulti(c, key, dst)
		if Debug {
			c.Debugf("reading from datastore: %#v", dst)
		}
		if errd != nil {
			return errd
		}
		// cache for next time
		errm = cache(key, dst, c)
	} else {
		errm = decodeItems(key, itemMap, dst)
		if Debug {
			c.Debugf("reading from memcache: %#v", dst)
		}
	}
	return errm
}

func GetMulti(c PersistenceContext, ids []key.Key, src interface{}) (err error) {
	dsIds := make([]*datastore.Key, len(ids))
	for index, id := range ids {
		dsIds[index] = gaekey.ToGAE(c, id)
	}
	getErr := datastore.GetMulti(c, dsIds, src)
	merr, isMerr := getErr.(appengine.MultiError)
	if !isMerr && getErr != nil {
		err = getErr
		return
	}
	srcVal := reflect.ValueOf(src)
	for index, id := range ids {
		if !isMerr || merr[index] == nil {
			el := srcVal.Index(index)
			for el.Kind() == reflect.Ptr {
				el = el.Elem()
			}
			el.FieldByName("Id").Set(reflect.ValueOf(id))
			if err = runProcess(c, el.Addr().Interface(), AfterLoadName, nil); err != nil {
				return
			}
		}
	}
	if isMerr && merr != nil {
		err = merr
	}
	return
}

func (d *DatastoreStorage) GetArchivedPosts(req *http.Request, datespec string) []blogplus.Activity {
	c := appengine.NewContext(req)
	datespecKey := datastore.NewKey(c, datespecKind, datespec, 0, nil)
	q := datastore.NewQuery(activityRef).Ancestor(datespecKey)
	t := q.Run(c)
	var keys []*datastore.Key
	for {
		var de DatespecEntity
		_, err := t.Next(&de)
		if err == datastore.Done {
			break
		}
		if err != nil {
			c.Errorf("query error:%#v", err)
			break
		}
		keys = append(keys, de.Id)
	}
	aelist := make([]ActivityEntity, len(keys))
	err := datastore.GetMulti(c, keys, aelist)
	if err != nil {
		c.Errorf("get multi error:%#v", err)
		return nil
	}
	var posts []blogplus.Activity
	for _, ae := range aelist {
		post, err := blogplus.DecodeActivity(ae.Post)
		if err != nil {
			c.Errorf("decode error:%#v", err)
			continue
		}
		posts = append(posts, post)
	}
	return posts
}

func (a *AppUser) GetBoards(c appengine.Context) (Boards []Board, err error) {
	Boards = make([]Board, len(a.BoardIDs))

	err = datastore.GetMulti(c, getIntKeys(c, "Board", a.BoardIDs...), Boards)

	return
}

func (d *Driver) GetMulti(key []*datastore.Key, dst interface{}) error {
	var keyLen = len(key)
	var fromIdx, toIdx int
	var v = reflect.ValueOf(dst)
	// TODO: split multiple goroutine
	for {
		fromIdx = toIdx
		toIdx = fromIdx + 999
		if toIdx > keyLen {
			toIdx = keyLen
		}
		_keys := key[fromIdx:toIdx]
		_data := v.Slice(fromIdx, toIdx).Interface()
		d.logOps(opRead, len(_keys), "GetMulti")
		if err := datastore.GetMulti(d.ctx, _keys, _data); err != nil {
			return err
		}
		v1 := reflect.ValueOf(_data)
		for i := 0; i < toIdx-fromIdx; i += 1 {
			v.Index(fromIdx + i).Set(v1.Index(i))
		}
		if toIdx == keyLen {
			break
		}
	}
	return nil
}

func fetchOptions(c appengine.Context, poll *Poll) ([]*Option, os.Error) {
	dst := make([]interface{}, poll.Options)
	options := make([]*Option, poll.Options)
	keys := make([]*datastore.Key, poll.Options)

	pollKey := datastore.NewKey(c, "poll", "", poll.Id, nil)
	for i := range keys {
		keys[i] = datastore.NewKey(c, "option", "", int64(i+1), pollKey)
		dst[i] = new(Option)
	}
	err := datastore.GetMulti(c, keys, dst)
	if err != nil {
		return nil, err
	}
	for i := range dst {
		opt, ok := dst[i].(*Option)
		if ok {
			options[i] = opt
			opt.Poll = pollKey
			opt.Id = keys[i].IntID()
		}
	}

	return options, err
}

func updateProfileEntities(
	context appengine.Context,
	profiles map[string]*Profile,
	generation string,
	kind string,
	count int) {
	// collect keys and new profile values into arrays
	keys := make([]*datastore.Key, 0)
	newvalues := make([]*Profile, 0)
	for username, profile := range profiles {
		key := datastore.NewKey(context, "Profile", username, 0, nil)
		keys = append(keys, key)
		newvalues = append(newvalues, profile)
	}
	// get all of the old profile values
	oldvalues := make([]*Profile, len(keys))
	err := datastore.GetMulti(context, keys, oldvalues)
	// if the old values are from the current generation, add their counts into the new values
	for i := 0; i < len(keys); i++ {
		if (oldvalues[i] != nil) && (oldvalues[i].Generation == generation) {
			newvalues[i].RadarCount += oldvalues[i].RadarCount
			newvalues[i].CommentCount += oldvalues[i].CommentCount
		}
	}
	// store all of the new values
	_, err = datastore.PutMulti(context, keys, newvalues)
	if err == nil {
		context.Infof("Updated %d profiles for %d %s", len(profiles), count, kind)
	} else {
		context.Infof("Error updating %d profiles for %d %s (%v)", len(profiles), count, kind, err)
	}
}

// Returns simulations favorited by and comments from the user id passed in the url
func InteractionsHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	userKeyName := vars["userID"]
	ctx := appengine.NewContext(r)
	var simulations []models.SimulationData
	var comments []models.CommentData

	// Check to see if the page user is the same as the logged in user
	userIsOwner := utils.IsOwner(userKeyName, ctx)

	// Only get favorited and commented information if it's the proper user
	// Don't display interaction data to any user except for the user who owns it
	if userIsOwner {
		// Get 50 of the most recent ratings made by the logged in user
		var ratingKeys []*datastore.Key
		var ratingObjs []models.Rating
		q := datastore.NewQuery("Rating").KeysOnly().Filter("AuthorKeyName =", userKeyName).Order("-CreationDate").Limit(50)
		ratingKeys, err := q.GetAll(ctx, ratingObjs)

		// Get the parent keys of the ratings made (these are the keys of the simulations the ratings were for)
		var simulationRateKeys []*datastore.Key
		for _, key := range ratingKeys {
			simulationRateKeys = append(simulationRateKeys, key.Parent())
		}

		// Get all of the simulation objects from the simulation keys
		simulationRateObjs := make([]models.Simulation, len(simulationRateKeys))
		err = datastore.GetMulti(ctx, simulationRateKeys, simulationRateObjs)
		if err != nil {
			controllers.ErrorHandler(w, r, err.Error(), http.StatusInternalServerError)
			return
		}

		// Build the proper simulation data objects from the simulation models
		simulations, err = utils.BuildSimulationDataSlice(ctx, simulationRateObjs, simulationRateKeys)
		if err != nil {
			controllers.ErrorHandler(w, r, "Could not load user simulations: "+err.Error(), http.StatusInternalServerError)
			return
		}

		// Get 50 of the most recent comments made by the logged in user
		q = datastore.NewQuery("Comment").Filter("AuthorKeyName =", userKeyName).Order("-CreationDate").Limit(50)
		comments, err = utils.GetCommentDataSlice(r, q)
		if err != nil {
			controllers.ErrorHandler(w, r, "Error fetching comments: "+err.Error(), http.StatusInternalServerError)
			return
		}
	}

	data := map[string]interface{}{
		"simulations":  simulations,
		"comments":     comments,
		"userIsOwner":  false,
		"userOwnsPage": userIsOwner,
	}

	controllers.BaseHandler(w, r, "user/interactions", data)
}

func (builder *stepsBuilder) LoadBatchFromDatastore(context appengine.Context) stream.EachFn {
	return func(data stream.T) {
		batch := data.(*DatastoreBatch)
		if err := datastore.GetMulti(context, batch.Keys, batch.Items); err != nil {
			if _, missingField := err.(*datastore.ErrFieldMismatch); !missingField {
				panic(err)
			}
		}
	}
}