Documentation ¶
Overview ¶
Package memcache provides a client for App Engine's distributed in-memory key-value store for small chunks of arbitrary data.
The fundamental operations get and set items, keyed by a string.
item0, err := memcache.Get(c, "key") if err != nil && err != memcache.ErrCacheMiss { return err } if err == nil { fmt.Fprintf(w, "memcache hit: Key=%q Val=[% x]\n", item0.Key, item0.Value) } else { fmt.Fprintf(w, "memcache miss\n") }
and
item1 := &memcache.Item{ Key: "foo", Value: []byte("bar"), } if err := memcache.Set(c, item1); err != nil { return err }
Index ¶
- Variables
- func Add(c appengine.Context, item *Item) error
- func AddMulti(c appengine.Context, item []*Item) []error
- func CompareAndSwap(c appengine.Context, item *Item) error
- func CompareAndSwapMulti(c appengine.Context, item []*Item) []error
- func Delete(c appengine.Context, key string) error
- func DeleteMulti(c appengine.Context, key []string) []error
- func GetMulti(c appengine.Context, key []string) (map[string]*Item, error)
- func Set(c appengine.Context, item *Item) error
- func SetMulti(c appengine.Context, item []*Item) []error
- type Codec
- type Item
- type Statistics
Constants ¶
This section is empty.
Variables ¶
var ( // ErrCacheMiss means that an operation failed // because the item wasn't present. ErrCacheMiss = errors.New("memcache: cache miss") // ErrCASConflict means that a CompareAndSwap call failed due to the // cached value being modified between the Get and the CompareAndSwap. // If the cached value was simply evicted rather than replaced, // ErrNotStored will be returned instead. ErrCASConflict = errors.New("memcache: compare-and-swap conflict") // ErrNoStats means that no statistics were available. ErrNoStats = errors.New("memcache: no statistics available") // ErrNotStored means that a conditional write operation (i.e. Add or // CompareAndSwap) failed because the condition was not satisfied. ErrNotStored = errors.New("memcache: item not stored") // ErrServerError means that a server error occurred. ErrServerError = errors.New("memcache: server error") )
Functions ¶
func Add ¶
Add writes the given item, if no value already exists for its key. ErrNotStored is returned if that condition is not met.
func AddMulti ¶
AddMulti is a batch version of Add. The returned slice will have the same length as the input slice.
func CompareAndSwap ¶
CompareAndSwap writes the given item that was previously returned by Get, if the value was neither modified or evicted between the Get and the CompareAndSwap calls. The item's Key should not change between calls but all other item fields may differ. ErrCASConflict is returned if the value was modified in between the calls. ErrNotStored is returned if the value was evicted in between the calls.
func CompareAndSwapMulti ¶
CompareAndSwapMulti is a batch version of CompareAndSwap. The returned slice will have the same length as the input slice.
func Delete ¶
Delete deletes the item for the given key. ErrCacheMiss is returned if the specified item can not be found. The key must be at most 250 bytes in length.
func DeleteMulti ¶
DeleteMulti is a batch version of Delete. The returned slice will have the same length as the input slice. If a given key cannot be found, its corresponding value in the returned error slice is set to ErrCacheMiss. Each key must be at most 250 bytes in length.
func GetMulti ¶
GetMulti is a batch version of Get. The returned map from keys to items may have fewer elements than the input slice, due to memcache cache misses. Each key must be at most 250 bytes in length.
Types ¶
type Codec ¶
type Codec struct { Marshal func(interface{}) ([]byte, error) Unmarshal func([]byte, interface{}) error }
Codec represents a symmetric pair of functions that implement a codec. Items stored into or retrieved from memcache using a Codec have their values marshaled or unmarshaled.
type Item ¶
type Item struct { // Key is the Item's key (250 bytes maximum). Key string // Value is the Item's value. Value []byte // Object is the Item's value for use with a Codec. Object interface{} // Flags are server-opaque flags whose semantics are entirely up to the // App Engine app. Flags uint32 // Expiration is the cache expiration time, in seconds: either a relative // time from now (up to 1 month), or an absolute Unix epoch time. // Zero means the Item has no expiration time. Expiration int32 // contains filtered or unexported fields }
Item is the unit of memcache gets and sets.
type Statistics ¶
type Statistics struct { Hits uint64 // Counter of cache hits Misses uint64 // Counter of cache misses ByteHits uint64 // Counter of bytes transferred for gets Items uint64 // Items currently in the cache Bytes uint64 // Size of all items currently in the cache Oldest int64 // Age of access of the oldest item, in seconds }
Statistics represents a set of statistics about the memcache cache.