// writeMutation ensures that this transaction can support the given key/value
// mutation.
//
// if getOnly is true, don't record the actual mutation data, just ensure that
// the key is in an included entity group (or add an empty entry for that
// group).
//
// if !getOnly && data == nil, this counts as a deletion instead of a Put.
//
// Returns an error if this key causes the transaction to cross too many entity
// groups.
func (td *txnDataStoreData) writeMutation(getOnly bool, key ds.Key, data ds.PropertyMap) error {
rk := string(keyBytes(dskey.Root(key)))
td.Lock()
defer td.Unlock()
if _, ok := td.muts[rk]; !ok {
limit := 1
if td.isXG {
limit = xgEGLimit
}
if len(td.muts)+1 > limit {
msg := "cross-group transaction need to be explicitly specified (xg=True)"
if td.isXG {
msg = "operating on too many entity groups in a single transaction"
}
return errors.New(msg)
}
td.muts[rk] = []txnMutation{}
}
if !getOnly {
td.muts[rk] = append(td.muts[rk], txnMutation{key, data})
}
return nil
}
func testGetMeta(c context.Context, k dsS.Key) int64 {
ds := dsS.Get(c)
mg := &MetaGroup{Parent: dskey.Root(k)}
if err := ds.Get(mg); err != nil {
panic(err)
}
return mg.Version
}
// GetEntityGroupVersion returns the entity group version for the entity group
// containing root. If the entity group doesn't exist, this function will return
// zero and a nil error.
func GetEntityGroupVersion(c context.Context, root dstore.Key) (int64, error) {
ds := dstore.Get(c)
egm := &EntityGroupMeta{Parent: dskey.Root(root)}
err := ds.Get(egm)
ret := egm.Version
if err == dstore.ErrNoSuchEntity {
// this is OK for callers. The version of the entity group is effectively 0
// in this case.
err = nil
}
return ret, err
}
func groupIDsKey(key ds.Key) []byte {
return keyBytes(dskey.New("", "", "__entity_group_ids__", "", 1, dskey.Root(key)))
}