goriakpbc: github.com/tpjg/goriakpbc Index | Files | Directories

package riak

import "github.com/tpjg/goriakpbc"

Package riak is a riak-client, inspired by the Ruby riak-client gem and the riakpbc go package from mrb. It implements a connection to Riak using protobuf.

Index

Package Files

bucket.go client.go counter.go defaultclient.go mapreduce.go message_codes.go model.go model_11.go rdatatype.go rdtcounter.go rdtmap.go rdtset.go rfile.go robject.go search.go

Constants

const (
    QuorumOne      = uint32(math.MaxUint32 - 1)
    QuorumMajority = uint32(math.MaxUint32 - 2)
    QuorumAll      = uint32(math.MaxUint32 - 3)
    QuorumDefault  = uint32(math.MaxUint32 - 4)
)

Protobuf symbolic quorum integer values

const (
    TYPE_COUNTER = 1
    TYPE_SET     = 2
    TYPE_MAP     = 3
)
const (
    COUNTER  = 1
    SET      = 2
    REGISTER = 3
    FLAG     = 4
    MAP      = 5
)

Variables

var (
    R1  = map[string]uint32{"r": 1}
    PR1 = map[string]uint32{"pr": 1}
    W1  = map[string]uint32{"w": 1}
    DW1 = map[string]uint32{"dw": 1}
    PW1 = map[string]uint32{"pw": 1}
)

Options for storing and retrieving data, only a few are defined, different values can be supplied by creating a map in the application, for example:

bucket.Get("key", map[string]int{"r":2})
var (
    BadNumberOfConnections = errors.New("Connection count <= 0")
    BadResponseLength      = errors.New("Response length too short")
    NoBucketName           = errors.New("No bucket name")
    BadMapReduceInputs     = errors.New("MapReduce inputs should be either a (single) index or bucket,key pairs - not both at")
    ChanWaitTimeout        = errors.New("Waiting for an available connection timed out")
)

Error definitions

var (
    ResolveNotImplemented     = errors.New("Resolve not implemented")
    DestinationError          = errors.New("Destination is not a pointer (to a struct)")
    DestinationIsNotModel     = errors.New("Destination has no riak.Model field")
    DestinationIsNotSlice     = errors.New("Must supply a slice to GetSiblings")
    DestinationLengthError    = errors.New("Length of slice does not match number of siblings")
    DestinationNotInitialized = errors.New("Destination struct is not initialized (correctly) using riak.New or riak.Load")
    ModelDoesNotMatch         = errors.New("Warning: struct name does not match _type in Riak")
    ModelNotNew               = errors.New("Destination struct already has an instantiated riak.Model (this struct is probably not new)")
    NoSiblingData             = errors.New("No non-empty sibling data")
)

Error definitions

var (
    NotFile     = errors.New("Not suitable to use as RFile")
    ErrorInFile = errors.New("Error in RFile")
)
var (
    NoDefaultClientConnection = errors.New("No (default) client connection")
)
var (
    NotFound = errors.New("Object not found")
)

Error definitions

func Close Uses

func Close()

Closes the connection of the default client.

func ConnectClient Uses

func ConnectClient(addr string) (err error)

Create the default client with a single connection to Riak.

func ConnectClientPool Uses

func ConnectClientPool(addr string, count int) (err error)

Create the default client, using a pool of connections. This is the recommended method to connect to Riak in an application. A single client instance can be used by multiple threads/goroutines and will not block operations if there are enough connections in the pool. NOTE: If an application needs connections to different Riak clusters it can use riak.NewClientPool or riak.NewClient.

func DeleteFrom Uses

func DeleteFrom(bucketname string, key string, options ...map[string]uint32) (err error)

Delete directly from a bucket, without creating a bucket object first

func ExistsIn Uses

func ExistsIn(bucketname string, key string, options ...map[string]uint32) (exists bool, err error)

Test if an object exists in a bucket directly, without creating a bucket object first

func Id Uses

func Id() (id string, err error)

Get the client Id

func IsWarning Uses

func IsWarning(err error) bool

Return is an error is really a warning, e.g. a common json error, or ModelDoesNotMatch.

func LoadModel Uses

func LoadModel(key string, dest Resolver, options ...map[string]uint32) (err error)

Load data into the model using the default bucket (from the Model's struct definition)

func LoadModelFrom Uses

func LoadModelFrom(bucketname string, key string, dest Resolver, options ...map[string]uint32) (err error)

The LoadModelFrom function retrieves the data from Riak using the default client and stores it in the struct that is passed as destination.

func NewModel Uses

func NewModel(key string, dest Resolver, options ...map[string]uint32) (err error)

Instantiate a new model (using the default client), setting the necessary fields, like the client. If key is not empty that key will be used, otherwise Riak will choose a key.

func NewModelIn Uses

func NewModelIn(bucketname string, key string, dest Resolver, options ...map[string]uint32) (err error)

Create a new Document Model (using the default client), passing in the bucketname and key.

func Ping Uses

func Ping() (err error)

Ping the server

func RunMapReduce Uses

func RunMapReduce(query string) (resp [][]byte, err error)

Run a MapReduce query directly

func ServerVersion Uses

func ServerVersion() (node string, version string, err error)

Get the server version for the default client

func SetId Uses

func SetId(id string) (err error)

Set the client Id

type Bucket Uses

type Bucket struct {
    // contains filtered or unexported fields
}

Implements access to a bucket and its properties

func NewBucket Uses

func NewBucket(name string) (*Bucket, error)

Return a new bucket using the client connection

func NewBucketType Uses

func NewBucketType(btype, name string) (*Bucket, error)

Return a new bucket using the client connection

func (*Bucket) AllowMult Uses

func (b *Bucket) AllowMult() bool

Return the allowMult property of a bucket

func (*Bucket) Delete Uses

func (b *Bucket) Delete(key string, options ...map[string]uint32) (err error)

Delete a key/value from the bucket

func (*Bucket) Exists Uses

func (b *Bucket) Exists(key string, options ...map[string]uint32) (exists bool, err error)

Test if an object exists

func (*Bucket) FetchCounter Uses

func (b *Bucket) FetchCounter(key string, options ...map[string]uint32) (obj *RDtCounter, err error)

func (*Bucket) FetchMap Uses

func (b *Bucket) FetchMap(key string, options ...map[string]uint32) (obj *RDtMap, err error)

func (*Bucket) FetchSet Uses

func (b *Bucket) FetchSet(key string, options ...map[string]uint32) (obj *RDtSet, err error)

func (*Bucket) Get Uses

func (b *Bucket) Get(key string, options ...map[string]uint32) (obj *RObject, err error)

Get an object

func (*Bucket) GetCounter Uses

func (b *Bucket) GetCounter(key string, options ...map[string]uint32) (c *Counter, err error)

Get a counter

func (*Bucket) GetCounterWithoutLoad Uses

func (b *Bucket) GetCounterWithoutLoad(key string, options ...map[string]uint32) (c *Counter, err error)

func (*Bucket) IndexQuery Uses

func (b *Bucket) IndexQuery(index string, key string) (keys []string, err error)

Return a list of keys using the index for a single key

func (*Bucket) IndexQueryPage Uses

func (b *Bucket) IndexQueryPage(index string, key string, results uint32, continuation string) (keys []string, next string, err error)

Return a page of keys using the index for a single key

func (*Bucket) IndexQueryRange Uses

func (b *Bucket) IndexQueryRange(index string, min string, max string) (keys []string, err error)

Return a list of keys using the index range query

func (*Bucket) IndexQueryRangePage Uses

func (b *Bucket) IndexQueryRangePage(index string, min string, max string, results uint32, continuation string) (keys []string, next string, err error)

Return a page of keys using the index range query

func (*Bucket) LastWriteWins Uses

func (b *Bucket) LastWriteWins() bool

Return the lastWriteWins property of a bucket

func (*Bucket) ListKeys Uses

func (b *Bucket) ListKeys() (response [][]byte, err error)

List all keys from bucket

func (*Bucket) NVal Uses

func (b *Bucket) NVal() uint32

Return the nval property of a bucket

func (*Bucket) Name Uses

func (b *Bucket) Name() string

Return the bucket name

func (*Bucket) New Uses

func (b *Bucket) New(key string, options ...map[string]uint32) *RObject

Create a new RObject. DEPRECATED, use NewObject instead

func (*Bucket) NewObject Uses

func (b *Bucket) NewObject(key string, options ...map[string]uint32) *RObject

Create a new RObject

func (*Bucket) Search Uses

func (b *Bucket) Search() bool

Return the search property of a bucket

func (*Bucket) SetAllowMult Uses

func (b *Bucket) SetAllowMult(allowMult bool) (err error)

Set the allowMult property of a bucket

func (*Bucket) SetLastWriteWins Uses

func (b *Bucket) SetLastWriteWins(lastWriteWins bool) (err error)

Set the lastWriteWins property of a bucket

func (*Bucket) SetNVal Uses

func (b *Bucket) SetNVal(nval uint32) (err error)

Set the nval property of a bucket

func (*Bucket) SetSearch Uses

func (b *Bucket) SetSearch(search bool) (err error)

Set the search property of a bucket

type Client Uses

type Client struct {
    // contains filtered or unexported fields
}

riak.Client the client interface

func New Uses

func New(addr string) *Client

Returns a new Client connection. DEPRECATED, use NewClient instead

func NewClient Uses

func NewClient(addr string) *Client

Returns a new Client connection

func NewClientPool Uses

func NewClientPool(addr string, count int) *Client

Returns a new Client with multiple connections to Riak

func NewPool Uses

func NewPool(addr string, count int) *Client

Returns a new Client with multiple connections to Riak. DEPRECATED, use NewClientPool instead

func (*Client) Bucket Uses

func (c *Client) Bucket(name string) (*Bucket, error)

Return a new bucket object. DEPRECATED, use NewBucket instead.

func (*Client) Close Uses

func (c *Client) Close()

Close the connection

func (*Client) Connect Uses

func (c *Client) Connect() error

Connects to a Riak server.

func (*Client) CreateFile Uses

func (c *Client) CreateFile(bucketname string, key string, contentType string, chunk_size int, options ...map[string]uint32) (*RFile, error)

Create a new RFile. Will overwrite/truncate existing data.

func (*Client) DeleteFrom Uses

func (c *Client) DeleteFrom(bucketname string, key string, options ...map[string]uint32) (err error)

Delete directly from a bucket, without creating a bucket object first

func (*Client) ExistsIn Uses

func (c *Client) ExistsIn(bucketname string, key string, options ...map[string]uint32) (exists bool, err error)

Test if an object exists in a bucket directly, without creating a bucket object first

func (*Client) GetCounterFrom Uses

func (c *Client) GetCounterFrom(bucketname string, key string, options ...map[string]uint32) (counter *Counter, err error)

Get counter directly from a bucket, without creating a bucket first

func (*Client) GetFrom Uses

func (c *Client) GetFrom(bucketname string, key string, options ...map[string]uint32) (obj *RObject, err error)

Get directly from a bucket, without creating a bucket first

func (*Client) Id Uses

func (c *Client) Id() (id string, err error)

Get the client Id

func (*Client) Key Uses

func (c *Client) Key(dest interface{}) (key string, err error)

Get a models Key, e.g. needed when Riak has picked it

func (*Client) Load Uses

func (c *Client) Load(bucketname string, key string, dest Resolver, options ...map[string]uint32) (err error)

Load data into model. DEPRECATED, use LoadModelFrom instead.

func (*Client) LoadModel Uses

func (c *Client) LoadModel(key string, dest Resolver, options ...map[string]uint32) (err error)

Load data into the model using the default bucket (from the Model's struct definition)

func (*Client) LoadModelFrom Uses

func (c *Client) LoadModelFrom(bucketname string, key string, dest Resolver, options ...map[string]uint32) (err error)

The LoadModelFrom function retrieves the data from Riak and stores it in the struct that is passed as destination. It stores some necessary information in the riak.Model field so it can be used later in other (Save) operations.

If the bucketname is empty ("") it'll be the default bucket, based on the riak.Model tag.

Using the "Device" struct as an example:

dev := &Device{} err := client.Load("devices", "12345", dev)

func (*Client) MapReduce Uses

func (c *Client) MapReduce() *MapReduce

func (*Client) New Uses

func (c *Client) New(bucketname string, key string, dest Resolver, options ...map[string]uint32) (err error)

Create a new model. DEPRECATED, use NewModelIn instead.

func (*Client) NewBucket Uses

func (c *Client) NewBucket(name string) (*Bucket, error)

Return a new bucket object

func (*Client) NewBucketType Uses

func (c *Client) NewBucketType(btype, name string) (*Bucket, error)

func (*Client) NewModel Uses

func (c *Client) NewModel(key string, dest Resolver, options ...map[string]uint32) (err error)

Instantiate a new model, setting the necessary fields, like the client. If key is not empty that key will be used, otherwise Riak will choose a key.

func (*Client) NewModelIn Uses

func (c *Client) NewModelIn(bucketname string, key string, dest Resolver, options ...map[string]uint32) (err error)

Create a new Document Model, passing in the bucketname and key. The key can be empty in which case Riak will pick a key. The destination must be a pointer to a struct that has the riak.Model field. If the bucketname is empty the default bucketname, based on the riak.Model tag will be used.

func (*Client) NewObjectIn Uses

func (c *Client) NewObjectIn(bucketname string, key string, options ...map[string]uint32) (*RObject, error)

Create a new RObject in a bucket directly, without creating a bucket object first

func (*Client) OpenFile Uses

func (c *Client) OpenFile(bucketname string, key string, options ...map[string]uint32) (*RFile, error)

Open a File. Will return an error if it does not exist in Riak yet or does not have the correct meta-tags to support File-like operations.

func (*Client) Ping Uses

func (c *Client) Ping() (err error)

Ping the server

func (*Client) RunMapReduce Uses

func (c *Client) RunMapReduce(query string) (resp [][]byte, err error)

Run a MapReduce query

func (*Client) Save Uses

func (c *Client) Save(dest Resolver) (err error)

Save a Document Model to Riak

func (*Client) SaveAs Uses

func (c *Client) SaveAs(newKey string, dest Resolver) (err error)

Save a Document Model to Riak under a new key, if empty a Key will be choosen by Riak

func (*Client) Search Uses

func (c *Client) Search(s *Search) ([]map[string][]byte, float32, uint32, error)

func (*Client) ServerVersion Uses

func (c *Client) ServerVersion() (node string, version string, err error)

Get the server version

func (*Client) SetChanWaitTimeout Uses

func (c *Client) SetChanWaitTimeout(waitTimeout time.Duration)

Set the maximum time to wait for a connection to be available in the pool. By default getConn() will wait forever.

func (*Client) SetConnectTimeout Uses

func (c *Client) SetConnectTimeout(timeout time.Duration)

Set the maximum time to wait for a connection to complete By default Connect() will wait around 3 minutes.

func (*Client) SetId Uses

func (c *Client) SetId(id string) (err error)

Set the client Id

func (*Client) SetKey Uses

func (c *Client) SetKey(newKey string, dest interface{}) (err error)

Set the Key value, note that this does not save the model, it only changes the data structure

type Counter Uses

type Counter struct {
    Bucket  *Bucket
    Key     string
    Value   int64
    Options []map[string]uint32
}

func (*Counter) Decrement Uses

func (c *Counter) Decrement(amount int64) (err error)

Decrement a counter by a given amount

func (*Counter) DecrementAndReload Uses

func (c *Counter) DecrementAndReload(amount int64) (err error)

Decrement a counter by a given amount and reload its value

func (*Counter) Destroy Uses

func (c *Counter) Destroy() (err error)

Destroy the counter

func (*Counter) Increment Uses

func (c *Counter) Increment(amount int64) (err error)

Increment a counter by a given amount

func (*Counter) IncrementAndReload Uses

func (c *Counter) IncrementAndReload(amount int64) (err error)

Increment a counter by a given amount and reload its value

func (*Counter) Reload Uses

func (c *Counter) Reload() (err error)

Reload the value of a counter

type Link struct {
    Bucket string
    Key    string
    Tag    string
}

A Riak link

type Many Uses

type Many []One

Link to many other models

func (*Many) Add Uses

func (m *Many) Add(dest Resolver) (err error)

Add a Link to the given Model (dest)

func (m *Many) AddLink(o One)

Add a given Link (One) directly

func (*Many) Contains Uses

func (m *Many) Contains(o One) bool

Return if a given Link is in the riak.Many slice

func (*Many) Len Uses

func (m *Many) Len() int

Return the number of Links

func (*Many) Remove Uses

func (m *Many) Remove(dest Resolver) (err error)

Remove a Link to the given Model (dest)

func (m *Many) RemoveLink(o One) (err error)

Remove a given Link (One) directly, e.g. so it can be used when iterating over a riak.Many slice

type MapKey Uses

type MapKey struct {
    Key  string
    Type pb.MapField_MapFieldType
}

type MapReduce Uses

type MapReduce struct {
    // contains filtered or unexported fields
}

An object to build a MapReduce job similar to how the Ruby client can build it by adding different stages.

func NewMapReduce Uses

func NewMapReduce() *MapReduce

Create a MapReduce object that can be used to build a MR query

func (*MapReduce) Add Uses

func (mr *MapReduce) Add(bucket string, key string) (err error)

func (*MapReduce) AddBucket Uses

func (mr *MapReduce) AddBucket(bucket string) (err error)

Add a whole bucket as input. Note that this ONLY works on buckets that have secondary indexes (2i) enabled since listing keys on a bucket without using indexes is dangerous on production clusters.

func (*MapReduce) AddBucketRange Uses

func (mr *MapReduce) AddBucketRange(bucket string, start string, end string) (err error)

Add a range of keys from one bucket using secondary indexes.

func (*MapReduce) AddIndex Uses

func (mr *MapReduce) AddIndex(bucket string, index string, key string) (err error)

Add a keys using a secondary index.

func (*MapReduce) AddIndexRange Uses

func (mr *MapReduce) AddIndexRange(bucket string, index string, start string, end string) (err error)

Add a range of keys using a secondary index.

func (*MapReduce) LinkBucket Uses

func (mr *MapReduce) LinkBucket(name string, keep bool)

func (*MapReduce) Map Uses

func (mr *MapReduce) Map(fun string, keep bool)

func (*MapReduce) MapErlang Uses

func (mr *MapReduce) MapErlang(module string, fun string, keep bool)

func (*MapReduce) MapObjectValue Uses

func (mr *MapReduce) MapObjectValue(keep bool)

func (*MapReduce) Query Uses

func (mr *MapReduce) Query() (query []byte, err error)

Generate the Query string

func (*MapReduce) Reduce Uses

func (mr *MapReduce) Reduce(fun string, keep bool)

func (*MapReduce) ReduceErlang Uses

func (mr *MapReduce) ReduceErlang(module string, fun string, arg string, keep bool)

func (*MapReduce) ReduceObjectCount Uses

func (mr *MapReduce) ReduceObjectCount(keep bool)

func (*MapReduce) Run Uses

func (mr *MapReduce) Run() (resp [][]byte, err error)

type Model Uses

type Model struct {
    // contains filtered or unexported fields
}

Make structs work like a Document Model, similar to how the Ruby based "ripple" gem works. This is done by parsing the JSON data and mapping it to the struct's fields. To enable easy integration with Ruby/ripple projects the struct "tag" feature of Go is used to possibly get around the naming convention differences between Go and Ruby (Uppercase starting letter required for export and typically CamelCase versus underscores). Also it stores the model/struct name as _type in Riak.

For example the following Ruby/Ripple class:

class Device
  include Ripple::Document
  property :ip, String
  property :description, String
  property :download_enabled, Boolean
end

can be mapped to the following Go class:

type Device struct {
	riak.Model       `riak:devices`
	Download_enabled bool    `riak:"download_enabled"`
	Ip               string  `riak:"ip"`
	Description      string  `riak:"description"`
}

Note that it is required to have a riak.Model field. Also if the field name in Ripple is equal the extra tag is not needed, (e.g. if the Ripple class above would have a "property :Ip, String").

func (*Model) CRC32 Uses

func (m *Model) CRC32() uint32

Return crc32 of the underlying robject data for easy comparison to other models

func (*Model) Delete Uses

func (m *Model) Delete() (err error)

Delete a Document Model

func (*Model) GetSiblings Uses

func (m *Model) GetSiblings(dest interface{}) (err error)

func (*Model) Indexes Uses

func (m *Model) Indexes() map[string][]string

Return the object's indexes. This allows an application to set custom secondary indexes on the object for later querying.

func (Model) Key Uses

func (m Model) Key() (key string)

Get a models Key, e.g. needed when Riak has picked it

func (*Model) Reload Uses

func (m *Model) Reload() (err error)

Reload a Document Model

func (*Model) Resolve Uses

func (*Model) Resolve(count int) (err error)

func (*Model) Save Uses

func (m *Model) Save() (err error)

Save a Document Model to Riak

func (*Model) SaveAs Uses

func (m *Model) SaveAs(newKey string) (err error)

Save a Document Model to Riak under a new key, if empty a Key will be choosen by Riak

func (Model) SetKey Uses

func (m Model) SetKey(newKey string) (err error)

Set the Key value, note that this does not save the model, it only changes the data structure

func (*Model) Siblings Uses

func (m *Model) Siblings(dest Resolver) (result interface{}, err error)

Allocates a slice of models for the result and populates it with the data from the siblings held in Riak.

func (*Model) Vclock Uses

func (m *Model) Vclock() (vclock []byte)

Return the object Vclock - this allows an application to detect whether Reload() loaded a newer version of the object

type One Uses

type One struct {
    // contains filtered or unexported fields
}

Link to one other model

func (*One) Empty Uses

func (o *One) Empty() bool

Test if the link is empty (not set)

func (*One) Equal Uses

func (o *One) Equal(e One) bool

Test for equality (bucket and key are equal)

func (*One) Get Uses

func (o *One) Get(dest Resolver) (err error)
func (o One) Link() (link Link)

func (*One) Set Uses

func (o *One) Set(dest Resolver) (err error)

Set the link to a given Model (dest)

func (o *One) SetLink(a One)

Set a link directly

type RDataType Uses

type RDataType interface {
    Store() error
    Destroy() error
}

type RDataTypeObject Uses

type RDataTypeObject struct {
    Bucket  *Bucket
    Key     string
    Options []map[string]uint32
    Context []uint8
}

func (*RDataTypeObject) Destroy Uses

func (obj *RDataTypeObject) Destroy() (err error)

type RDtCounter Uses

type RDtCounter struct {
    RDataTypeObject
    Value *int64
    Incr  int64
}

func (*RDtCounter) GetValue Uses

func (counter *RDtCounter) GetValue() int64

func (*RDtCounter) Increment Uses

func (counter *RDtCounter) Increment(value int64)

func (*RDtCounter) Store Uses

func (counter *RDtCounter) Store() (err error)

func (*RDtCounter) ToOp Uses

func (counter *RDtCounter) ToOp() *pb.DtOp

type RDtFlag Uses

type RDtFlag struct {
    Value    bool
    Enabled  bool
    Disabled bool
}

func (*RDtFlag) Disable Uses

func (f *RDtFlag) Disable()

func (*RDtFlag) Enable Uses

func (f *RDtFlag) Enable()

func (*RDtFlag) GetValue Uses

func (f *RDtFlag) GetValue() bool

type RDtMap Uses

type RDtMap struct {
    RDataTypeObject
    Values   map[MapKey]interface{}
    ToAdd    []*pb.MapUpdate
    ToRemove []*pb.MapField
}

func (*RDtMap) AddCounter Uses

func (m *RDtMap) AddCounter(key string) (e *RDtCounter)

func (*RDtMap) AddFlag Uses

func (m *RDtMap) AddFlag(key string) (e *RDtFlag)

func (*RDtMap) AddMap Uses

func (m *RDtMap) AddMap(key string) (e *RDtMap)

func (*RDtMap) AddRegister Uses

func (m *RDtMap) AddRegister(key string) (e *RDtRegister)

func (*RDtMap) AddSet Uses

func (m *RDtMap) AddSet(key string) (e *RDtSet)

func (*RDtMap) FetchCounter Uses

func (m *RDtMap) FetchCounter(key string) (e *RDtCounter)

func (*RDtMap) FetchFlag Uses

func (m *RDtMap) FetchFlag(key string) (e *RDtFlag)

func (*RDtMap) FetchMap Uses

func (m *RDtMap) FetchMap(key string) (e *RDtMap)

func (*RDtMap) FetchRegister Uses

func (m *RDtMap) FetchRegister(key string) (e *RDtRegister)

func (*RDtMap) FetchSet Uses

func (m *RDtMap) FetchSet(key string) (e *RDtSet)

func (*RDtMap) Init Uses

func (m *RDtMap) Init(mapvalues []*pb.MapEntry)

func (*RDtMap) Print Uses

func (m *RDtMap) Print()

func (*RDtMap) PrintInt Uses

func (m *RDtMap) PrintInt(indent int)

func (*RDtMap) RemoveCounter Uses

func (m *RDtMap) RemoveCounter(key string)

func (*RDtMap) RemoveFlag Uses

func (m *RDtMap) RemoveFlag(key string)

func (*RDtMap) RemoveMap Uses

func (m *RDtMap) RemoveMap(key string)

func (*RDtMap) RemoveRegister Uses

func (m *RDtMap) RemoveRegister(key string)

func (*RDtMap) RemoveSet Uses

func (m *RDtMap) RemoveSet(key string)

func (*RDtMap) Size Uses

func (m *RDtMap) Size() int

func (*RDtMap) Store Uses

func (m *RDtMap) Store() (err error)

func (*RDtMap) ToOp Uses

func (m *RDtMap) ToOp() *pb.DtOp

type RDtRegister Uses

type RDtRegister struct {
    Value    []byte
    NewValue []byte
}

func (*RDtRegister) GetValue Uses

func (f *RDtRegister) GetValue() []byte

func (*RDtRegister) Update Uses

func (r *RDtRegister) Update(value []byte)

type RDtSet Uses

type RDtSet struct {
    RDataTypeObject
    Value    [][]byte
    ToAdd    [][]byte
    ToRemove [][]byte
}

func (*RDtSet) Add Uses

func (set *RDtSet) Add(value []byte)

func (*RDtSet) GetValue Uses

func (set *RDtSet) GetValue() [][]byte

func (*RDtSet) Remove Uses

func (set *RDtSet) Remove(value []byte)

func (*RDtSet) Store Uses

func (set *RDtSet) Store() (err error)

func (*RDtSet) ToOp Uses

func (set *RDtSet) ToOp() *pb.DtOp

type RFile Uses

type RFile struct {
    // contains filtered or unexported fields
}
The RFile struct stores (large) values in Riak and behaves very similar

to a regular os.File object. It implements the io.Reader, io.Writer and io.Seeker interfaces. The value is split into chunks because really large values (>10Mb) can't be stored efficiently in Riak and also because growing or changing large values is inefficient (changing a single byte would require a PUT of the entire, possibly large, value).

func CreateFile Uses

func CreateFile(bucketname string, key string, contentType string, chunk_size int, options ...map[string]uint32) (*RFile, error)

func OpenFile Uses

func OpenFile(bucketname string, key string, options ...map[string]uint32) (*RFile, error)

func (*RFile) Flush Uses

func (r *RFile) Flush() error

Force a write of the underlying root RObject (e.g. after changing Meta and/or Indexes)

func (*RFile) Indexes Uses

func (r *RFile) Indexes() map[string][]string

Expose Indexes of the underlying root RObject

func (*RFile) Meta Uses

func (r *RFile) Meta() map[string]string

Expose Meta information of the underlying root RObject

func (*RFile) Read Uses

func (r *RFile) Read(p []byte) (n int, err error)

Implements the io.Reader interface

func (*RFile) Seek Uses

func (r *RFile) Seek(offset int64, whence int) (int64, error)

Implements the io.Seeker interface

func (*RFile) Size Uses

func (r *RFile) Size() int

func (*RFile) Write Uses

func (r *RFile) Write(p []byte) (n int, err error)

Implements the io.Writer interface

type RObject Uses

type RObject struct {
    Bucket       *Bucket
    Vclock       []byte
    Key          string
    ContentType  string
    Data         []byte
    Links        []Link
    Meta         map[string]string
    Indexes      map[string][]string
    Vtag         string
    LastMod      uint32
    LastModUsecs uint32

    Siblings []Sibling
    Options  []map[string]uint32
    // contains filtered or unexported fields
}

An RObject is an object or document that is or can be stored in Riak

func GetFrom Uses

func GetFrom(bucketname string, key string, options ...map[string]uint32) (obj *RObject, err error)

Get directly from a bucket, without creating a bucket first

func NewObjectIn Uses

func NewObjectIn(bucketname string, key string, options ...map[string]uint32) (*RObject, error)

Create a new RObject in a bucket directly, without creating a bucket object first

func (obj *RObject) AddLink(link Link) bool

Add a link if it is not already in the Links slics, returns false if already present

func (*RObject) Conflict Uses

func (obj *RObject) Conflict() bool

Returns true if the object was fetched with multiple siblings (AllowMult=true on the bucket)

func (*RObject) Destroy Uses

func (obj *RObject) Destroy() (err error)

Delete the object from Riak

func (*RObject) LinkTo Uses

func (obj *RObject) LinkTo(target *RObject, tag string)

Add a link to another object (does not store the object, must explicitly call "Store()")

func (*RObject) Reload Uses

func (obj *RObject) Reload() (err error)

Reload an object if it has changed (new Vclock)

func (*RObject) Store Uses

func (obj *RObject) Store() (err error)

Store an RObject

type Resolver Uses

type Resolver interface {
    Resolve(int) error
}
type Search struct {
    Q       string
    Index   string
    Rows    uint32
    Start   uint32
    Sort    string
    Filter  string
    Df      string
    Op      string
    PreSort string
    Fields  []string
}

type Sibling Uses

type Sibling struct {
    ContentType  string
    Data         []byte
    Links        []Link
    Meta         map[string]string
    Indexes      map[string][]string
    Vtag         string
    LastMod      uint32
    LastModUsecs uint32
}

An object van have siblings that can each have their own content

Directories

PathSynopsis
json
pbPackage riak is a generated protocol buffer package.

Package riak imports 17 packages (graph) and is imported by 6 packages. Updated 2016-07-15. Refresh now. Tools for package owners.