作者：f4re
项目：Crono
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
}
作者：shick
项目：storytim
// 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
}
作者：samtho
项目：withsr
// 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
}
作者：virusdav
项目：nopullrequest
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)
}
}
作者：timburk
项目：openrada
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
}
作者：reedlabot
项目：scribblevin
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)
}
作者：oschmi
项目：cachestor
// 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
}
作者：DaviWe
项目：utils-
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
}
作者：uka
项目：blogplus-ga
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
}
作者：pakoha
项目：appengine-bugtracke
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
}
作者：speedlan
项目：wc
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
}
作者：broad
项目：Poll
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
}
作者：timburk
项目：openrada
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)
}
}
作者：samold
项目：principi
// 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)
}
作者：drborge
项目：app
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)
}
}
}
}
作者：elegio
项目：Scrib
func projectTop(e env, projectId string) bool {
e.w.Header().Set("Content-type", "text/html; charset=utf-8")
userKey, done := getUser(e)
if done {
return true
}
snapshot, snapshotKey, done := getLastSnapshot(e, userKey, projectId)
if done {
return true
}
nodes := make([]Node, len(snapshot.Nodes))
nodeKeys := make([]*datastore.Key, 0, len(snapshot.Nodes))
for _, k := range snapshot.Nodes {
nodeKeys = append(nodeKeys, datastore.NewKey(e.ctx, "node", "", k, snapshotKey))
}
if err := datastore.GetMulti(e.ctx, nodeKeys, nodes); err != nil {
e.w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(e.w, `Could not load all nodes in the snapshot`)
log.Println("Error loading nodes in snapshot", err)
return true
}
treeToSend := make(map[string]interface{})
for i, node := range nodes {
id := strconv.FormatInt(nodeKeys[i].IntID(), 10)
val := map[string]interface{}{
"name": node.Name,
}
if node.Folder {
val["collapsed"] = node.Collapsed
if node.Children != nil {
val["children"] = node.Children
} else {
val["children"] = make([]int64, 0, 0)
}
}
treeToSend[id] = val
}
treeToSend["root"] = snapshot.Top
fmt.Fprintf(e.w, `<html><head><link rel="stylesheet" type="text/css" href="static/site.css" /></head><body>`)
fmt.Fprintf(e.w, `<script type="text/javascript">var StartingContent=null;function countWords(t){var c=0;t.replace(/\S+/g,function(){c++});return c};var StartingTree=`)
if err := json.NewEncoder(e.w).Encode(treeToSend); err != nil {
e.w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(e.w, "Could not generate json from the tree")
log.Println("Error generating json from tree", err)
return true
}
fmt.Fprintf(e.w, `</script><div id="app"></div><script type="text/javascript" src="static/client.js"></script>`)
fmt.Fprintf(e.w, `<script type="text/javascript">window.onload=function(){scribe.core.run()}</script>`)
fmt.Fprintf(e.w, `</body></html>`)
return true
}
作者：knights
项目：goda
func (dai Person_dai) GetMulti(c appengine.Context, keys []*datastore.Key) ([]*Person, error) {
// batch get.
var entities = make([]*Person, len(keys))
//TODO: if have not such entity for any-one key?
err := datastore.GetMulti(c, keys, entities)
if err != nil {
return nil, err
}
return entities, nil
}
作者：nickdufresn
项目：GAE-Billing-Syste
func (ctx *Context) GetVendorMulti(keys []*datastore.Key) ([]*Vendor, error) {
vendors := make([]*Vendor, len(keys))
for idx, _ := range vendors {
vendors[idx] = new(Vendor)
}
err := datastore.GetMulti(ctx.c, keys, vendors)
return vendors, err
}
作者：nelsa
项目：atomicgame
// Load multiple datastore values into a slice of models
func GetModels(ctx appengine.Context, keys []*datastore.Key, modelSlice []models.Model) error {
err := datastore.GetMulti(ctx, keys, modelSlice)
var (
index int
model models.Model
)
for index, model = range modelSlice {
model.SetKey(keys[index])
}
return err
}
作者：nickdufresn
项目：GAE-Billing-Syste
func (ctx *Context) GetCompanyMulti(keys []*datastore.Key) ([]*Company, error) {
companies := make([]*Company, len(keys))
for idx, _ := range companies {
companies[idx] = new(Company)
}
err := datastore.GetMulti(ctx.c, keys, companies)
return companies, err
}
