Pacote google.golang.org/appengine/memcache (v1.6.7)

O pacote memcache fornece um cliente para o armazenamento de chave-valor na memória distribuída do App Engine para pequenos blocos de dados arbitrários.

As operações fundamentais são get e set itens, codificadas por uma 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")
}

e

item1 := &memcache.Item{
    Key:   "foo",
    Value: []byte("bar"),
}
if err := memcache.Set(c, item1); err != nil {
    return err
}

Variáveis

ErrCacheMiss, ErrCASConflict, ErrNoStats, ErrNotStored, ErrServerError

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")
)

Gob, JSON

var (
	// Gob is a Codec that uses the gob package.
	Gob = Codec{gobMarshal, gobUnmarshal}
	// JSON is a Codec that uses the json package.
	JSON = Codec{json.Marshal, json.Unmarshal}
)

Funções

func Add

func Add(c context.Context, item *Item) error

Add gravará o item determinado se ainda não existir um valor para a chave. ErrNotStored será retornado se essa condição não for atendida.

func AddMulti

func AddMulti(c context.Context, item []*Item) error

AddMulti é uma versão em lote de Add. appengineError pode ser retornado.

func CompareAndSwap

func CompareAndSwap(c context.Context, item *Item) error

CompareAndSwap gravará o item indicado que foi retornado anteriormente por Get, se o valor não tiver sido modificado nem removido entre as chamadas Get e CompareAndSwap. A Key do item não precisa mudar entre chamadas, mas todos os outros campos de item podem ser diferentes. ErrCASConflict será retornado se o valor tiver sido modificado entre as chamadas. ErrNotStored será retornado se o valor tiver sido removido entre as chamadas.

func CompareAndSwapMulti

func CompareAndSwapMulti(c context.Context, item []*Item) error

CompareAndSwapMulti é uma versão em lote de CompareAndSwap. appengine.MultiError pode ser retornado.

func Delete

func Delete(c context.Context, key string) error

Delete exclui o item da chave indicada. ErrCacheMiss será retornado se o item especificado não puder ser encontrado. A chave precisa ter pelo menos 250 bytes.

func DeleteMulti

func DeleteMulti(c context.Context, key []string) error

DeleteMulti é uma versão em lote de Delete. Se alguma chave não for encontrada, um appengine.MultiError será retornado. Cada chave precisa ter no máximo 250 bytes.

func Flush

func Flush(c context.Context) error

Flush limpa todos os itens do memcache.

func GetMulti

func GetMulti(c context.Context, key []string) (map[string]*Item, error)

GetMulti é uma versão em lote de Get. O mapa retornado de chaves para itens pode ter menos elementos que a fatia de entrada, por causa de perdas de cache do memcache. Cada chave precisa ter no máximo 250 bytes.

func Increment

func Increment(c context.Context, key string, delta int64, initialValue uint64) (newValue uint64, err error)

Increment incrementa atomicamente o valor decimal na chave indicada pelo delta e retorna o novo valor. O valor precisa caber em um uint64. Overflow encapsula, e underflow é limitado a zero. O delta fornecido pode ser negativo. Se a chave não existir em memcache, o valor inicial fornecido será usado para preenchê-lo atomicamente antes do delta ser aplicado. A chave precisa ter pelo menos 250 bytes.

func IncrementExisting

func IncrementExisting(c context.Context, key string, delta int64) (newValue uint64, err error)

IncrementExisting funciona como Increment, mas pressupõe que a chave já exista em memcache e não utiliza um valor inicial. IncrementExisting poderá salvar o trabalho se o cálculo do valor inicial for caro. Um erro será retornado se o item especificado não puder ser encontrado.

função PeekMulti

func PeekMulti(c context.Context, key []string) (map[string]*Item, error)

PeekMulti é uma versão em lote do Peek. Ele é semelhante a GetMulti, mas também preenche Item.Timestamps.

func Set

func Set(c context.Context, item *Item) error

Set grava o item indicado, incondicionalmente.

func SetMulti

func SetMulti(c context.Context, item []*Item) error

SetMulti é uma versão em lote de Set. appengine.MultiError pode ser retornado.

Codec

type Codec struct {
	Marshal   func(interface{}) ([]byte, error)
	Unmarshal func([]byte, interface{}) error
}

Codec representa um par simétrico de funções que implementam um codec. Itens armazenados ou recuperados do Memcache usando um Codec têm os valores com ou sem marshaling.

Todos os métodos fornecidos para Codec se comportam de maneira semelhante à função de nível do pacote com o mesmo nome.

func (Codec) Add

func (cd Codec) Add(c context.Context, item *Item) error

Add gravará o item determinado se ainda não existir um valor para a chave. ErrNotStored será retornado se essa condição não for atendida.

func (Codec) AddMulti

func (cd Codec) AddMulti(c context.Context, items []*Item) error

AddMulti é uma versão em lote de Add. appengineError pode ser retornado.

func (Codec) CompareAndSwap

func (cd Codec) CompareAndSwap(c context.Context, item *Item) error

CompareAndSwap gravará o item indicado que foi retornado anteriormente por Get, se o valor não tiver sido modificado nem removido entre as chamadas Get e CompareAndSwap. A Key do item não precisa mudar entre chamadas, mas todos os outros campos de item podem ser diferentes. ErrCASConflict será retornado se o valor tiver sido modificado entre as chamadas. ErrNotStored será retornado se o valor tiver sido removido entre as chamadas.

func (Codec) CompareAndSwapMulti

func (cd Codec) CompareAndSwapMulti(c context.Context, items []*Item) error

CompareAndSwapMulti é uma versão em lote de CompareAndSwap. appengine.MultiError pode ser retornado.

func (Codec) Get

func (cd Codec) Get(c context.Context, key string, v interface{}) (*Item, error)

Get acessa o item da chave indicada e decodifica o valor obtido em v. ErrCacheMiss é retornado quando há uma ausência de cache do Memcache. A chave precisa ter no máximo 250 bytes de comprimento.

func (Codec) Set

func (cd Codec) Set(c context.Context, item *Item) error

Set grava o item indicado, incondicionalmente.

func (Codec) SetMulti

func (cd Codec) SetMulti(c context.Context, items []*Item) error

SetMulti é uma versão em lote de Set. appengine.MultiError pode ser retornado.

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 maximum duration that the item will stay
	// in the cache.
	// The zero value means the Item has no expiration time.
	// Subsecond precision is ignored.
	// This is not set when getting items.
	Expiration time.Duration

	// ItemTimestamps are server values only returned when calling Peek and PeekMulti.
	// The timestamps are nil when calling Get and GetMulti.
	Timestamps ItemTimestamps
	// contains filtered or unexported fields
}

Item é a unidade de gets e sets do memcache.

func Get

func Get(c context.Context, key string) (*Item, error)

Get consegue o item da chave indicada. ErrCacheMiss é retornado para uma ausência no cache do Memcache. A chave precisa ter no máximo 250 bytes.

função Peek

func Peek(c context.Context, key string) (*Item, error)

A exibição recebe o item da chave especificada e também preenche Item.Timestamps. ErrCacheMiss é retornado para uma ausência no cache do Memcache. A chave precisa ter no máximo 250 bytes.

Carimbos de data/hora do item

type ItemTimestamps struct {
	// Expiration is related to Item.Expiration but it is a Time (not a Duration),
	// provided by the server. It is not meant to be set by the user.
	Expiration *time.Time
	// LastAccess is the last time the Item was accessed.
	LastAccess *time.Time
}

ItemTimestamps são carimbos de data/hora fornecidos opcionalmente pelo servidor. Consulte Peek e PeekMulti.

Estatísticas

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 representa um conjunto de estatísticas sobre o cache do memcache. Ele pode incluir itens que expiraram, mas ainda não foram removidos do cache.

func Stats

func Stats(c context.Context) (*Statistics, error)

Stats recupera as estatísticas atuais do memcache.