Golang datastore.PutMulti函数代码示例

func sendYoHandler(w http.ResponseWriter, r *http.Request) {
	client := getYoClient()
	var user string
	timeNow := time.Now()
	time1hr := timeNow.Add(-59 * time.Minute)

	q := datastore.NewQuery("Reminder").Filter("Delivered =", 0).Filter("TimeStamp <=", time1hr)

	var reminders []Reminder
	c := appengine.NewContext(r)
	keys, err := q.GetAll(c, &reminders)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	for i := range reminders {
		user = reminders[i].UserName
		err := client.YoUser(user, r)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}

		reminders[i].Delivered = 1
	}
	datastore.PutMulti(c, keys, reminders)
}

func createAllStatusTypes(c appengine.Context) error {
	names := [...]string{
		STATUS_NEW_APP,
		STATUS_EMAIL_SEARCHING,
		STATUS_EMAIL_READY,
		STATUS_EMAIL_BODY_READY,
		STATUS_EMAIL_BODY_GENERATING,
		STATUS_EMAIL_SENT,
		STATUS_EMAIL_VIEWED,
		STATUS_EMAIL_CLICKED,
	}

	var keys []*datastore.Key
	var values []*Status

	for _, value := range names {
		status := &Status{
			Name:    value,
			Created: time.Now(),
		}
		key := datastore.NewKey(c, DATASTORE_STATUS, value, 0, nil)
		keys = append(keys, key)
		values = append(values, status)
	}

	_, err := datastore.PutMulti(c, keys, values)
	return 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)
	}
}

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

	r.ParseForm()
	versions := []Version{}
	keys := []*datastore.Key{}
	for _, os := range r.Form["OS"] {
		v := Version{
			Current:      r.FormValue("Current"),
			New:          r.FormValue("New"),
			OS:           os,
			Info:         r.FormValue("Info"),
			Download:     r.FormValue("Download"),
			ReleaseNotes: r.FormValue("ReleaseNotes"),
		}
		versions = append(versions, v)
		keys = append(keys, datastore.NewIncompleteKey(c, "Version", nil))
	}
	_, err := datastore.PutMulti(c, keys, versions)

	if err != nil {
		c.Errorf("Error storing new version: %v", err)
		http.Error(w,
			"I had a problem storing your new version: "+err.Error(),
			500)
		return
	}

	http.Redirect(w, r, "/admin/version/list", 303)
}

func CFix(c mpg.Context, w http.ResponseWriter, r *http.Request) {
	gn := goon.FromContext(c)
	url := r.FormValue("feed")
	c.Infof("fix feed %s", url)
	f := Feed{Url: url}
	if err := gn.Get(&f); err != nil {
		c.Criticalf("cfix err: %v", err)
		serveError(w, err)
		return
	}

	q := datastore.NewQuery("S").Ancestor(gn.Key(&f))
	var ss []*Story
	keys, err := q.GetAll(c, &ss)
	if err != nil {
		c.Errorf("getall err: %v", err)
		serveError(w, err)
		return
	}
	c.Infof("trying to fix %v stories", len(ss))
	const putLimit = 500
	for i := 0; i <= len(keys)/putLimit; i++ {
		lo := i * putLimit
		hi := (i + 1) * putLimit
		if hi > len(keys) {
			hi = len(keys)
		}
		c.Infof("%v - %v", lo, hi)
		if _, err := datastore.PutMulti(c, keys[lo:hi], ss[lo:hi]); err != nil {
			c.Errorf("err: %v, %v, %v", lo, hi, err)
		}
	}
}

func (d *Driver) PutMulti(key []*datastore.Key, src interface{}) ([]*datastore.Key, error) {
	var keyLen = len(key)
	var fromIdx, toIdx int
	var v = reflect.ValueOf(src)
	var resultKeys = make([]*datastore.Key, 0)
	// TODO: split multiple goroutine
	for {
		fromIdx = toIdx
		toIdx = fromIdx + d.PutSplitThreshold
		if toIdx > keyLen {
			toIdx = keyLen
		}
		_keys := key[fromIdx:toIdx]
		_data := v.Slice(fromIdx, toIdx).Interface()
		d.logOps(opRead, len(_keys), "PutMulti")
		if updatedKeys, err := datastore.PutMulti(d.ctx, _keys, _data); err != nil {
			return resultKeys, err
		} else {
			resultKeys = append(resultKeys, updatedKeys...)
		}
		if toIdx == keyLen {
			break
		}
	}
	return resultKeys, nil
}

func DeleteTag(c appengine.Context, tag string) (err os.Error) {
	// Fetch bookmarks with this tag
	q := datastore.NewQuery("Bookmark").Filter("UserId=", user.Current(c).Id).Filter("Tags=", tag)
	count, err := q.Count(c)
	if err != nil {
		return err
	}
	var bms []Bookmark
	keys, err := q.GetAll(c, &bms)
	if err != nil {
		return err
	}

	// Remove tag from bookmark
	bmsRef := make([]interface{}, count)
	for i := 0; i < len(bms); i++ {
		bmsRef[i] = &bms[i]
		btags := bms[i].Tags
		for j := 0; j < len(btags); j++ {
			if btags[j] == tag {
				bms[i].Tags = append(btags[:j], btags[j+1:]...)
				break
			}
		}
	}

	// Put them back on the datastore
	_, err = datastore.PutMulti(c, keys, bmsRef)
	return err
}

// perform an import using the data we've decoded in jsonData
func (self *importer) doImport() {
	// initialize our list of dirty cache entries with the top-level items
	// these (and more) will be flushed from the cache when we're done
	self.dirtyCacheEntries = append(self.dirtyCacheEntries, []string{
		"/dish",
		"/dish/",
		"/menu",
		"/menu/",
		"/ingredient",
		"/ingredient/",
	}...)
	// build an index of the tags currently in the datastore
	self.indexCurrentTags()
	self.importIngredients()
	self.importDishes()
	self.importMeasuredIngredients()
	self.importPairings()
	self.importMenus()
	// add the tags we collected
	_, err := datastore.PutMulti(self.c, self.newTagKeys, self.newTags)
	check(err)
	// clear the cache
	lid := self.lid.Encode()
	// prefix each entry with the library id
	for i, _ := range self.dirtyCacheEntries {
		self.dirtyCacheEntries[i] = lid + self.dirtyCacheEntries[i]
	}
	// clear them all
	memcache.DeleteMulti(self.c, self.dirtyCacheEntries)
}

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

	// start putMulti1 OMIT
	keys := make([]*datastore.Key, 10)
	for i, _ := range keys {
		keys[i] = datastore.NewKey(c, "Book", "", int64(i+1), nil) // HL
	}

	books := make([]Book, 10)
	for i, _ := range books {
		number := i + 1
		books[i] = Book{
			fmt.Sprintf("book-%d", number),
			fmt.Sprintf("author-%d", number%2),
			number * 100,
			time.Now(),
		}
	}
	_, err := datastore.PutMulti(c, keys, books) // HL
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	// end putMulti1 OMIT

	w.Write([]byte("success"))
}

func (db *AppEngineDB) SaveUsages(u []Usage) error {
	n := len(u)
	keys := make([]*datastore.Key, n, n)
	for i, v := range u {
		if v.UserID != "" {
			if v.Key != "" {
				key, err := datastore.DecodeKey(v.Key)
				if err == nil {
					keys[i] = key
				}
			} else {
				keys[i] = datastore.NewIncompleteKey(db.ctx, "Usage", nil)
			}
		}
	}

	keys, err := datastore.PutMulti(db.ctx, keys, u)
	if err != nil {
		return err
	}

	for i, v := range keys {
		u[i].Key = v.Encode()
	}
	return nil
}

//save article and save tags transaction
func (this *ArticleMetaData) Save(ctx Context) (err error) {
	c := ctx.GAEContext
	uuid, err := GenUUID()
	if err != nil {
		return err
	}
	this.Id = uuid
	k := datastore.NewKey(c, "Article", uuid, 0, nil)

	err = datastore.RunInTransaction(c, func(c appengine.Context) error {
		if len(this.Tags) > 0 {
			tags := make([]Tags, len(this.Tags))
			tagsKey := make([]*datastore.Key, len(this.Tags))
			for id, tag := range this.Tags {
				tags[id].ArticleId = uuid
				tags[id].Tag = tag
				tagId := uuid + tag
				tagsKey[id] = datastore.NewKey(c, "Tags", tagId, 0, nil)
			}
			_, err = datastore.PutMulti(c, tagsKey, tags)
			if err != nil {
				return err
			}
		}
		_, err = datastore.Put(c, k, this)
		return err

	}, &datastore.TransactionOptions{XG: true})

	return err
}

func (d *DatastoreStorage) StorePosts(req *http.Request, posts []blogplus.Activity) {
	c := appengine.NewContext(req)
	var keys []*datastore.Key
	var src []interface{}
	for _, post := range posts {
		if d.filter != nil && !d.filter(post) {
			c.Debugf("ignore post:%s", post.Id)
			continue
		}
		datespec := blogplus.GetDatespec(post.Published)
		data, err := blogplus.EncodeActivity(post)
		if err != nil {
			c.Errorf("encode error:%#v", err)
			continue
		}
		c.Infof("store %s datespec %s", post.Id, datespec)
		datekey := datastore.NewKey(c, activityRef, post.Id, 0, datastore.NewKey(c, datespecKind, datespec, 0, nil))
		key := datastore.NewKey(c, activityKind, post.Id, 0, nil)
		keys = append(keys, datekey)
		src = append(src, &DatespecEntity{Id: key})
		keys = append(keys, key)
		src = append(src, &ActivityEntity{
			Id:        post.Id,
			Published: post.Published,
			Post:      data})
	}
	_, err := datastore.PutMulti(c, keys, src)
	if err != nil {
		c.Errorf("put error:%#v", err)
	}
}

// import all of the dishes from jsonData
func (self *importer) importDishes() {
	// get the previously listed dishes
	// build an index by name
	prevDishesByImportId := self.indexItems(self.NewQuery("Dish"), &Dish{},
		func(key *datastore.Key, item interface{}) string {
			return item.(*Dish).Id
		})
	// lists for dishes being written
	count := len(self.jsonData.Dishes)
	putItems := make([]interface{}, 0, count)
	putKeys := make([]*datastore.Key, 0, count)
	putIds := make([]string, 0, count)

	// prepare all the dishes
	for index, _ := range self.jsonData.Dishes {
		i := &self.jsonData.Dishes[index]
		id := i.Id
		key := self.restoreKey(id, self.lid)
		if key.Incomplete() {
			// check if we have an item of the same name already
			if ikey, ok := prevDishesByImportId[id]; ok {
				self.fixUpKeys[id] = ikey
				key = ikey
			}
		}
		putItems = append(putItems, i)
		putKeys = append(putKeys, key)
		putIds = append(putIds, id)
	}
	// put all the dishes
	outKeys, err := datastore.PutMulti(self.c, putKeys, putItems)
	check(err)
	// update the fixUpKeys for any new items
	for index, putKey := range putKeys {
		if putKey.Incomplete() {
			self.fixUpKeys[putIds[index]] = outKeys[index]
		} else {
			self.dirtyCacheEntries = append(self.dirtyCacheEntries, "/dish/"+putKey.Encode())
			self.dirtyCacheEntries = append(self.dirtyCacheEntries, "/dish/"+putKey.Encode()+"/tags/")
			self.dirtyCacheEntries = append(self.dirtyCacheEntries, "/dish/"+putKey.Encode()+"/keywords/")
			self.dirtyCacheEntries = append(self.dirtyCacheEntries, "/dish/"+putKey.Encode()+"/pairing/")
			self.dirtyCacheEntries = append(self.dirtyCacheEntries, "/dish/"+putKey.Encode()+"/mi/")
		}
	}

	// add tags
	self.importTags(putIds, outKeys)
	// update keywords
	for index, _ := range putItems {
		dish := putItems[index].(*Dish)
		words := make(map[string]bool)
		addWords(dish.Name, words)
		addWords(dish.Source, words)
		for tag, _ := range self.allTags[outKeys[index].Encode()] {
			addWords(tag, words)
		}
		updateKeywords(self.c, outKeys[index], words)
	}
}

func PutMemo(c appengine.Context, username string, m Memo) (err error) {
	memos := []Memo{m}
	var keys = []*datastore.Key{
		datastore.NewIncompleteKey(c, "Memo", UserMemoKey(c, username))}

	_, err = datastore.PutMulti(c, keys, memos)
	return
}

// PutMulti is a batch version of Put.
//
// src must satisfy the same conditions as the dst argument to GetMulti.
func PutMulti(c appengine.Context, key []*datastore.Key, src interface{}) ([]*datastore.Key, error) {
	if Debug {
		c.Debugf("writing to datastore: %#v", src)
	}
	key, errd := datastore.PutMulti(c, key, src)
	memcache.DeleteMulti(c, encodeKeys(key))
	return key, errd
}