aerospike

package module

Go to main page

Versions in this module

v4

v4.5.2

May 28, 2021

v4.5.1

May 27, 2021

v4.5.0

Apr 12, 2021

Changes in this version

type BufferEx

+ WriteBool func(b bool) int

type Client

+ func (clnt *Client) QueryPartitionObjects(policy *QueryPolicy, statement *Statement, objChan interface{}, ...) (*Recordset, error)

+ func (clnt *Client) ScanPartitionObjects(apolicy *ScanPolicy, objChan interface{}, partitionFilter *PartitionFilter, ...) (*Recordset, error)

v4.4.0

Mar 12, 2021

v4.3.0

Mar 1, 2021

Changes in this version

type PartitionFilter

+ func NewPartitionFilterAll() *PartitionFilter

+ func (pf *PartitionFilter) IsDone() bool

v4.2.0

Feb 12, 2021

Changes in this version

type Client

+ func (clnt *Client) QueryPartitions(policy *QueryPolicy, statement *Statement, partitionFilter *PartitionFilter) (*Recordset, error)

+ func (clnt *Client) ScanPartitions(apolicy *ScanPolicy, partitionFilter *PartitionFilter, namespace string, ...) (*Recordset, error)

type FieldType

+ const DIGEST_ARRAY

+ const PID_ARRAY

+ const SCAN_MAX_RECORDS

type Host

+ func NewHosts(addresses ...string) ([]*Host, error)

type Key

+ func (ky *Key) PartitionId() int

type MultiPolicy

+ MaxRecords int64

+ type PartitionFilter struct

+ func NewPartitionFilterById(partitionId int) *PartitionFilter

+ func NewPartitionFilterByKey(key *Key) *PartitionFilter

+ func NewPartitionFilterByRange(begin, count int) *PartitionFilter

v4.1.0

Jan 26, 2021

Changes in this version

type Client

+ DefaultInfoPolicy *InfoPolicy

+ func (clnt *Client) SetXDRFilter(policy *InfoPolicy, datacenter string, namespace string, ...) error

type ClientPolicy

+ ErrorRateWindow int

+ MaxErrorRate int

type FilterExpression

+ func ExpMemorySize() *FilterExpression

v4.0.0

Nov 27, 2020

Changes in this version

+ const BitExpOpADD

+ const BitExpOpAND

+ const BitExpOpCOUNT

+ const BitExpOpGET

+ const BitExpOpGETINT

+ const BitExpOpINSERT

+ const BitExpOpLSCAN

+ const BitExpOpLSHIFT

+ const BitExpOpNOT

+ const BitExpOpOR

+ const BitExpOpREMOVE

+ const BitExpOpRESIZE

+ const BitExpOpRSCAN

+ const BitExpOpRSHIFT

+ const BitExpOpSET

+ const BitExpOpSETINT

+ const BitExpOpSUBTRACT

+ const BitExpOpXOR

+ const BitWriteFlagsCreateOnly

+ const BitWriteFlagsDefault

+ const BitWriteFlagsNoFail

+ const BitWriteFlagsPartial

+ const BitWriteFlagsUpdateOnly

+ const DataAdmin

+ const HLLWriteFlagsAllowFold

+ const HLLWriteFlagsCreateOnly

+ const HLLWriteFlagsDefault

+ const HLLWriteFlagsNoFail

+ const HLLWriteFlagsUpdateOnly

+ const ListWriteFlagsAddUnique

+ const ListWriteFlagsDefault

+ const ListWriteFlagsInsertBounded

+ const ListWriteFlagsNoFail

+ const ListWriteFlagsPartial

+ const MODIFY

+ const MapWriteFlagsCreateOnly

+ const MapWriteFlagsDefault

+ const MapWriteFlagsNoFail

+ const MapWriteFlagsPartial

+ const MapWriteFlagsUpdateOnly

+ const Read

+ const ReadWrite

+ const ReadWriteUDF

+ const SysAdmin

+ const TTLDontExpire

+ const TTLDontUpdate

+ const TTLServerDefault

+ const UserAdmin

+ const Write

+ var DefaultBufferSize = 64 * 1024

+ var HllExpOpADD = 1

+ var HllExpOpCOUNT = 50

+ var HllExpOpDESCRIBE = 55

+ var HllExpOpINTERSECTCOUNT = 53

+ var HllExpOpMAYCONTAIN = 56

+ var HllExpOpSIMILARITY = 54

+ var HllExpOpUNION = 51

+ var HllExpOpUNIONCOUNT = 52

+ var MapOrder = struct{ ... }

+ var MapReturnType = struct{ ... }

+ var MapWriteMode = struct{ ... }

+ var MaxBufferSize = 1024 * 1024 * 120

+ func NewPredExpAnd(nexpr uint16) *predExpAnd

+ func NewPredExpGeoJSONBin(name string) *predExpBin

+ func NewPredExpGeoJSONContains() *predExpCompare

+ func NewPredExpGeoJSONValue(val string) *predExpGeoJSONValue

+ func NewPredExpGeoJSONVar(name string) *predExpVar

+ func NewPredExpGeoJSONWithin() *predExpCompare

+ func NewPredExpIntegerBin(name string) *predExpBin

+ func NewPredExpIntegerEqual() *predExpCompare

+ func NewPredExpIntegerGreater() *predExpCompare

+ func NewPredExpIntegerGreaterEq() *predExpCompare

+ func NewPredExpIntegerLess() *predExpCompare

+ func NewPredExpIntegerLessEq() *predExpCompare

+ func NewPredExpIntegerUnequal() *predExpCompare

+ func NewPredExpIntegerValue(val int64) *predExpIntegerValue

+ func NewPredExpIntegerVar(name string) *predExpVar

+ func NewPredExpListBin(name string) *predExpBin

+ func NewPredExpListIterateAnd(name string) *predExpIter

+ func NewPredExpListIterateOr(name string) *predExpIter

+ func NewPredExpMapBin(name string) *predExpBin

+ func NewPredExpMapKeyIterateAnd(name string) *predExpIter

+ func NewPredExpMapKeyIterateOr(name string) *predExpIter

+ func NewPredExpMapValIterateAnd(name string) *predExpIter

+ func NewPredExpMapValIterateOr(name string) *predExpIter

+ func NewPredExpNot() *predExpNot

+ func NewPredExpOr(nexpr uint16) *predExpOr

+ func NewPredExpRecDeviceSize() *predExpMD

+ func NewPredExpRecDigestModulo(mod int32) *predExpMDDigestModulo

+ func NewPredExpRecLastUpdate() *predExpMD

+ func NewPredExpRecVoidTime() *predExpMD

+ func NewPredExpStringBin(name string) *predExpBin

+ func NewPredExpStringEqual() *predExpCompare

+ func NewPredExpStringRegex(cflags uint32) *predExpStringRegex

+ func NewPredExpStringUnequal() *predExpCompare

+ func NewPredExpStringValue(val string) *predExpStringValue

+ func NewPredExpStringVar(name string) *predExpVar

+ func NewPredExpUnknownBin(name string) *predExpBin

+ func PackBool(cmd BufferEx, val bool) (int, error)

+ func PackBytes(cmd BufferEx, b []byte) (int, error)

+ func PackFloat32(cmd BufferEx, val float32) (int, error)

+ func PackFloat64(cmd BufferEx, val float64) (int, error)

+ func PackInt64(cmd BufferEx, val int64) (int, error)

+ func PackJson(cmd BufferEx, theMap map[string]interface{}) (int, error)

+ func PackList(cmd BufferEx, list ListIter) (int, error)

+ func PackMap(cmd BufferEx, theMap MapIter) (int, error)

+ func PackNil(cmd BufferEx) (int, error)

+ func PackString(cmd BufferEx, val string) (int, error)

+ func PackUInt64(cmd BufferEx, val uint64) (int, error)

+ func RequestInfo(conn *Connection, names ...string) (map[string]string, error)

+ func SetAerospikeTag(tag string)

+ func SetLuaPath(lpath string)

+ type AdminPolicy struct

+ Timeout time.Duration

+ func NewAdminPolicy() *AdminPolicy

+ type AerospikeBlob interface

+ EncodeBlob func() ([]byte, error)

+ type AuthMode int

+ const AuthModeExternal

+ const AuthModeInternal

+ type BasePolicy struct

+ FilterExpression *FilterExpression

+ MaxRetries int

+ PredExp []PredExp

+ Priority Priority

+ ReadModeAP ReadModeAP

+ ReadModeSC ReadModeSC

+ ReplicaPolicy ReplicaPolicy

+ SendKey bool

+ SleepBetweenRetries time.Duration

+ SleepMultiplier float64

+ SocketTimeout time.Duration

+ TotalTimeout time.Duration

+ UseCompression bool

+ func NewPolicy() *BasePolicy

+ func (p *BasePolicy) GetBasePolicy() *BasePolicy

+ type BatchError struct

+ Errors map[*Node]error

+ type BatchPolicy struct

+ AllowInline bool

+ AllowPartialResults bool

+ ConcurrentNodes int

+ SendSetName bool

+ func NewBatchPolicy() *BatchPolicy

+ type BatchRead struct

+ BinNames []string

+ Key *Key

+ ReadAllBins bool

+ Record *Record

+ func NewBatchRead(key *Key, binNames []string) *BatchRead

+ func NewBatchReadHeader(key *Key) *BatchRead

+ func (br *BatchRead) String() string

+ type Bin struct

+ Name string

+ Value Value

+ func NewBin(name string, value interface{}) *Bin

+ func (bn *Bin) String() string

+ type BinMap map[string]interface

+ type BitOverflowAction int

+ const BitOverflowActionFail

+ const BitOverflowActionSaturate

+ const BitOverflowActionWrap

+ type BitPolicy struct

+ func DefaultBitPolicy() *BitPolicy

+ func NewBitPolicy(flags int) *BitPolicy

+ type BitResizeFlags int

+ const BitResizeFlagsDefault

+ const BitResizeFlagsFromFront

+ const BitResizeFlagsGrowOnly

+ const BitResizeFlagsShrinkOnly

+ type BufferEx interface

+ Write func(b []byte) (int, error)

+ WriteByte func(b byte) error

+ WriteFloat32 func(float float32) (int, error)

+ WriteFloat64 func(float float64) (int, error)

+ WriteInt16 func(num int16) (int, error)

+ WriteInt32 func(num int32) (int, error)

+ WriteInt64 func(num int64) (int, error)

+ WriteString func(s string) (int, error)

+ WriteUint16 func(num uint16) (int, error)

+ WriteUint32 func(num uint32) (int, error)

+ WriteUint64 func(num uint64) (int, error)

+ type BytesValue []byte

+ func NewBlobValue(object AerospikeBlob) BytesValue

+ func NewBytesValue(bytes []byte) BytesValue

+ func (vl BytesValue) EstimateSize() (int, error)

+ func (vl BytesValue) GetObject() interface{}

+ func (vl BytesValue) GetType() int

+ func (vl BytesValue) String() string

+ type CDTContext struct

+ func CtxListIndex(index int) *CDTContext

+ func CtxListIndexCreate(index int, order ListOrderType, pad bool) *CDTContext

+ func CtxListRank(rank int) *CDTContext

+ func CtxListValue(key Value) *CDTContext

+ func CtxMapIndex(index int) *CDTContext

+ func CtxMapKey(key Value) *CDTContext

+ func CtxMapKeyCreate(key Value, order mapOrderType) *CDTContext

+ func CtxMapRank(rank int) *CDTContext

+ func CtxMapValue(key Value) *CDTContext

+ type Client struct

+ DefaultAdminPolicy *AdminPolicy

+ DefaultBatchPolicy *BatchPolicy

+ DefaultPolicy *BasePolicy

+ DefaultQueryPolicy *QueryPolicy

+ DefaultScanPolicy *ScanPolicy

+ DefaultWritePolicy *WritePolicy

+ func NewClient(hostname string, port int) (*Client, error)

+ func NewClientWithPolicy(policy *ClientPolicy, hostname string, port int) (*Client, error)

+ func NewClientWithPolicyAndHost(policy *ClientPolicy, hosts ...*Host) (*Client, error)

+ func (clnt *Client) Add(policy *WritePolicy, key *Key, binMap BinMap) error

+ func (clnt *Client) AddBins(policy *WritePolicy, key *Key, bins ...*Bin) error

+ func (clnt *Client) Append(policy *WritePolicy, key *Key, binMap BinMap) error

+ func (clnt *Client) AppendBins(policy *WritePolicy, key *Key, bins ...*Bin) error

+ func (clnt *Client) BatchExists(policy *BatchPolicy, keys []*Key) ([]bool, error)

+ func (clnt *Client) BatchGet(policy *BatchPolicy, keys []*Key, binNames ...string) ([]*Record, error)

+ func (clnt *Client) BatchGetComplex(policy *BatchPolicy, records []*BatchRead) error

+ func (clnt *Client) BatchGetHeader(policy *BatchPolicy, keys []*Key) ([]*Record, error)

+ func (clnt *Client) BatchGetObjects(policy *BatchPolicy, keys []*Key, objects []interface{}) (found []bool, err error)

+ func (clnt *Client) ChangePassword(policy *AdminPolicy, user string, password string) error

+ func (clnt *Client) Close()

+ func (clnt *Client) Cluster() *Cluster

+ func (clnt *Client) CreateComplexIndex(policy *WritePolicy, namespace string, setName string, indexName string, ...) (*IndexTask, error)

+ func (clnt *Client) CreateIndex(policy *WritePolicy, namespace string, setName string, indexName string, ...) (*IndexTask, error)

+ func (clnt *Client) CreateRole(policy *AdminPolicy, roleName string, privileges []Privilege, ...) error

+ func (clnt *Client) CreateUser(policy *AdminPolicy, user string, password string, roles []string) error

+ func (clnt *Client) Delete(policy *WritePolicy, key *Key) (bool, error)

+ func (clnt *Client) DropIndex(policy *WritePolicy, namespace string, setName string, indexName string) error

+ func (clnt *Client) DropRole(policy *AdminPolicy, roleName string) error

+ func (clnt *Client) DropUser(policy *AdminPolicy, user string) error

+ func (clnt *Client) Execute(policy *WritePolicy, key *Key, packageName string, functionName string, ...) (interface{}, error)

+ func (clnt *Client) ExecuteUDF(policy *QueryPolicy, statement *Statement, packageName string, ...) (*ExecuteTask, error)

+ func (clnt *Client) ExecuteUDFNode(policy *QueryPolicy, node *Node, statement *Statement, packageName string, ...) (*ExecuteTask, error)

+ func (clnt *Client) Exists(policy *BasePolicy, key *Key) (bool, error)

+ func (clnt *Client) Get(policy *BasePolicy, key *Key, binNames ...string) (*Record, error)

+ func (clnt *Client) GetHeader(policy *BasePolicy, key *Key) (*Record, error)

+ func (clnt *Client) GetNodeNames() []string

+ func (clnt *Client) GetNodes() []*Node

+ func (clnt *Client) GetObject(policy *BasePolicy, key *Key, obj interface{}) error

+ func (clnt *Client) GrantPrivileges(policy *AdminPolicy, roleName string, privileges []Privilege) error

+ func (clnt *Client) GrantRoles(policy *AdminPolicy, user string, roles []string) error

+ func (clnt *Client) IsConnected() bool

+ func (clnt *Client) ListUDF(policy *BasePolicy) ([]*UDF, error)

+ func (clnt *Client) Operate(policy *WritePolicy, key *Key, operations ...*Operation) (*Record, error)

+ func (clnt *Client) Prepend(policy *WritePolicy, key *Key, binMap BinMap) error

+ func (clnt *Client) PrependBins(policy *WritePolicy, key *Key, bins ...*Bin) error

+ func (clnt *Client) Put(policy *WritePolicy, key *Key, binMap BinMap) error

+ func (clnt *Client) PutBins(policy *WritePolicy, key *Key, bins ...*Bin) error

+ func (clnt *Client) PutObject(policy *WritePolicy, key *Key, obj interface{}) (err error)

+ func (clnt *Client) Query(policy *QueryPolicy, statement *Statement) (*Recordset, error)

+ func (clnt *Client) QueryAggregate(policy *QueryPolicy, statement *Statement, packageName, functionName string, ...) (*Recordset, error)

+ func (clnt *Client) QueryExecute(policy *QueryPolicy, writePolicy *WritePolicy, statement *Statement, ...) (*ExecuteTask, error)

+ func (clnt *Client) QueryNode(policy *QueryPolicy, node *Node, statement *Statement) (*Recordset, error)

+ func (clnt *Client) QueryNodeObjects(policy *QueryPolicy, node *Node, statement *Statement, objChan interface{}) (*Recordset, error)

+ func (clnt *Client) QueryObjects(policy *QueryPolicy, statement *Statement, objChan interface{}) (*Recordset, error)

+ func (clnt *Client) QueryRole(policy *AdminPolicy, role string) (*Role, error)

+ func (clnt *Client) QueryRoles(policy *AdminPolicy) ([]*Role, error)

+ func (clnt *Client) QueryUser(policy *AdminPolicy, user string) (*UserRoles, error)

+ func (clnt *Client) QueryUsers(policy *AdminPolicy) ([]*UserRoles, error)

+ func (clnt *Client) RegisterUDF(policy *WritePolicy, udfBody []byte, serverPath string, language Language) (*RegisterTask, error)

+ func (clnt *Client) RegisterUDFFromFile(policy *WritePolicy, clientPath string, serverPath string, language Language) (*RegisterTask, error)

+ func (clnt *Client) RemoveUDF(policy *WritePolicy, udfName string) (*RemoveTask, error)

+ func (clnt *Client) RevokePrivileges(policy *AdminPolicy, roleName string, privileges []Privilege) error

+ func (clnt *Client) RevokeRoles(policy *AdminPolicy, user string, roles []string) error

+ func (clnt *Client) ScanAll(apolicy *ScanPolicy, namespace string, setName string, binNames ...string) (*Recordset, error)

+ func (clnt *Client) ScanAllObjects(apolicy *ScanPolicy, objChan interface{}, namespace string, setName string, ...) (*Recordset, error)

+ func (clnt *Client) ScanNode(apolicy *ScanPolicy, node *Node, namespace string, setName string, ...) (*Recordset, error)

+ func (clnt *Client) ScanNodeObjects(apolicy *ScanPolicy, node *Node, objChan interface{}, namespace string, ...) (*Recordset, error)

+ func (clnt *Client) SetWhitelist(policy *AdminPolicy, roleName string, whitelist []string) error

+ func (clnt *Client) Stats() (map[string]interface{}, error)

+ func (clnt *Client) String() string

+ func (clnt *Client) Touch(policy *WritePolicy, key *Key) error

+ func (clnt *Client) Truncate(policy *WritePolicy, namespace, set string, beforeLastUpdate *time.Time) error

+ func (clnt *Client) WarmUp(count int) (int, error)

+ type ClientPolicy struct

+ AuthMode AuthMode

+ ClusterName string

+ ConnectionQueueSize int

+ FailIfNotConnected bool

+ IdleTimeout time.Duration

+ IgnoreOtherSubnetAliases bool

+ IpMap map[string]string

+ LimitConnectionsToQueueSize bool

+ LoginTimeout time.Duration

+ MinConnectionsPerNode int

+ OpeningConnectionThreshold int

+ Password string

+ RackAware bool

+ RackId int

+ TendInterval time.Duration

+ Timeout time.Duration

+ TlsConfig *tls.Config

+ UseServicesAlternate bool

+ User string

+ func NewClientPolicy() *ClientPolicy

+ func (cp *ClientPolicy) RequiresAuthentication() bool

+ type Cluster struct

+ func NewCluster(policy *ClientPolicy, hosts []*Host) (*Cluster, error)

+ func (clstr *Cluster) AddSeeds(hosts []*Host)

+ func (clstr *Cluster) ClientPolicy() (res ClientPolicy)

+ func (clstr *Cluster) Close()

+ func (clstr *Cluster) GetAliases() map[Host]*Node

+ func (clstr *Cluster) GetNodeByName(nodeName string) (*Node, error)

+ func (clstr *Cluster) GetNodes() []*Node

+ func (clstr *Cluster) GetRandomNode() (*Node, error)

+ func (clstr *Cluster) GetSeeds() []Host

+ func (clstr *Cluster) IsConnected() bool

+ func (clstr *Cluster) MigrationInProgress(timeout time.Duration) (res bool, err error)

+ func (clstr *Cluster) Password() (res []byte)

+ func (clstr *Cluster) String() string

+ func (clstr *Cluster) WaitUntillMigrationIsFinished(timeout time.Duration) (err error)

+ func (clstr *Cluster) WarmUp(count int) (int, error)

+ type CommitLevel int

+ const COMMIT_ALL

+ const COMMIT_MASTER

+ type Connection struct

+ func NewConnection(policy *ClientPolicy, host *Host) (*Connection, error)

+ func (ctn *Connection) Authenticate(user string, password string) error

+ func (ctn *Connection) Close()

+ func (ctn *Connection) IsConnected() bool

+ func (ctn *Connection) Login(policy *ClientPolicy) error

+ func (ctn *Connection) Read(buf []byte, length int) (total int, err error)

+ func (ctn *Connection) SetTimeout(deadline time.Time, socketTimeout time.Duration) error

+ func (ctn *Connection) Write(buf []byte) (total int, err error)

+ type DropIndexTask struct

+ func NewDropIndexTask(cluster *Cluster, namespace string, indexName string) *DropIndexTask

+ func (tski *DropIndexTask) IsDone() (bool, error)

+ func (tski *DropIndexTask) OnComplete() chan error

+ type ExecuteTask struct

+ func NewExecuteTask(cluster *Cluster, statement *Statement) *ExecuteTask

+ func (etsk *ExecuteTask) IsDone() (bool, error)

+ func (etsk *ExecuteTask) OnComplete() chan error

+ type ExpRegexFlags int

+ const ExpRegexFlagEXTENDED

+ const ExpRegexFlagICASE

+ const ExpRegexFlagNEWLINE

+ const ExpRegexFlagNONE

+ const ExpRegexFlagNOSUB

+ type ExpType uint

+ var ExpTypeBLOB ExpType = 6

+ var ExpTypeBOOL ExpType = 1

+ var ExpTypeFLOAT ExpType = 7

+ var ExpTypeGEO ExpType = 8

+ var ExpTypeHLL ExpType = 9

+ var ExpTypeINT ExpType = 2

+ var ExpTypeLIST ExpType = 4

+ var ExpTypeMAP ExpType = 5

+ var ExpTypeNIL ExpType = 0

+ var ExpTypeSTRING ExpType = 3

+ type ExpressionArgument interface

+ type FieldType int

+ const BATCH_INDEX

+ const BATCH_INDEX_WITH_SET

+ const DIGEST_RIPE

+ const DIGEST_RIPE_ARRAY

+ const FILTER_EXP

+ const INDEX_FILTER

+ const INDEX_LIMIT

+ const INDEX_NAME

+ const INDEX_ORDER_BY

+ const INDEX_RANGE

+ const INDEX_TYPE

+ const KEY

+ const NAMESPACE

+ const QUERY_BINLIST

+ const RECORDS_PER_SECOND

+ const SCAN_OPTIONS

+ const SCAN_TIMEOUT

+ const TABLE

+ const TRAN_ID

+ const UDF_ARGLIST

+ const UDF_FUNCTION

+ const UDF_OP

+ const UDF_PACKAGE_NAME

+ type Filter struct

+ func NewContainsFilter(binName string, indexCollectionType IndexCollectionType, value interface{}) *Filter

+ func NewContainsRangeFilter(binName string, indexCollectionType IndexCollectionType, begin, end int64) *Filter

+ func NewEqualFilter(binName string, value interface{}) *Filter

+ func NewGeoRegionsContainingPointFilter(binName, point string) *Filter

+ func NewGeoRegionsContainingPointForCollectionFilter(binName string, collectionType IndexCollectionType, point string) *Filter

+ func NewGeoWithinRadiusFilter(binName string, lng, lat, radius float64) *Filter

+ func NewGeoWithinRadiusForCollectionFilter(binName string, collectionType IndexCollectionType, lng, lat, radius float64) *Filter

+ func NewGeoWithinRegionFilter(binName, region string) *Filter

+ func NewGeoWithinRegionForCollectionFilter(binName string, collectionType IndexCollectionType, region string) *Filter

+ func NewRangeFilter(binName string, begin int64, end int64) *Filter

+ func (fltr *Filter) EstimateSize() (int, error)

+ func (fltr *Filter) IndexCollectionType() IndexCollectionType

+ type FilterExpression struct

+ func ExpAnd(exps ...*FilterExpression) *FilterExpression

+ func ExpBinExists(name string) *FilterExpression

+ func ExpBinType(name string) *FilterExpression

+ func ExpBitAdd(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitAnd(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitCount(bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitGet(bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitGetInt(bit_offset *FilterExpression, bit_size *FilterExpression, signed bool, ...) *FilterExpression

+ func ExpBitInsert(policy *BitPolicy, byte_offset *FilterExpression, value *FilterExpression, ...) *FilterExpression

+ func ExpBitLScan(bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitLShift(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitNot(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitOr(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitRScan(bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitRShift(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitRemove(policy *BitPolicy, byte_offset *FilterExpression, byte_size *FilterExpression, ...) *FilterExpression

+ func ExpBitResize(policy *BitPolicy, byte_size *FilterExpression, resize_flags BitResizeFlags, ...) *FilterExpression

+ func ExpBitSet(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitSetInt(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitSubtract(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBitXor(policy *BitPolicy, bit_offset *FilterExpression, bit_size *FilterExpression, ...) *FilterExpression

+ func ExpBlobBin(name string) *FilterExpression

+ func ExpBlobVal(val []byte) *FilterExpression

+ func ExpBoolVal(val bool) *FilterExpression

+ func ExpDeviceSize() *FilterExpression

+ func ExpDigestModulo(modulo int64) *FilterExpression

+ func ExpEq(left *FilterExpression, right *FilterExpression) *FilterExpression

+ func ExpFloatBin(name string) *FilterExpression

+ func ExpFloatVal(val float64) *FilterExpression

+ func ExpGeoBin(name string) *FilterExpression

+ func ExpGeoCompare(left *FilterExpression, right *FilterExpression) *FilterExpression

+ func ExpGeoVal(val string) *FilterExpression

+ func ExpGreater(left *FilterExpression, right *FilterExpression) *FilterExpression

+ func ExpGreaterEq(left *FilterExpression, right *FilterExpression) *FilterExpression

+ func ExpHLLAdd(policy *HLLPolicy, list *FilterExpression, bin *FilterExpression) *FilterExpression

+ func ExpHLLAddWithIndex(policy *HLLPolicy, list *FilterExpression, index_bit_count *FilterExpression, ...) *FilterExpression

+ func ExpHLLAddWithIndexAndMinHash(policy *HLLPolicy, list *FilterExpression, index_bit_count *FilterExpression, ...) *FilterExpression

+ func ExpHLLBin(name string) *FilterExpression

+ func ExpHLLDescribe(bin *FilterExpression) *FilterExpression

+ func ExpHLLGetCount(bin *FilterExpression) *FilterExpression

+ func ExpHLLGetIntersectCount(list *FilterExpression, bin *FilterExpression) *FilterExpression

+ func ExpHLLGetSimilarity(list *FilterExpression, bin *FilterExpression) *FilterExpression

+ func ExpHLLGetUnion(list *FilterExpression, bin *FilterExpression) *FilterExpression

+ func ExpHLLGetUnionCount(list *FilterExpression, bin *FilterExpression) *FilterExpression

+ func ExpHLLMayContain(list *FilterExpression, bin *FilterExpression) *FilterExpression

+ func ExpIntBin(name string) *FilterExpression

+ func ExpIntVal(val int64) *FilterExpression

+ func ExpIsTombstone() *FilterExpression

+ func ExpKey(exp_type ExpType) *FilterExpression

+ func ExpKeyExists() *FilterExpression

+ func ExpLastUpdate() *FilterExpression

+ func ExpLess(left *FilterExpression, right *FilterExpression) *FilterExpression

+ func ExpLessEq(left *FilterExpression, right *FilterExpression) *FilterExpression

+ func ExpListAppend(policy *ListPolicy, value *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListAppendItems(policy *ListPolicy, list *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListBin(name string) *FilterExpression

+ func ExpListClear(bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListGetByIndex(returnType ListReturnType, value_type ExpType, index *FilterExpression, ...) *FilterExpression

+ func ExpListGetByIndexRange(returnType ListReturnType, index *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListGetByIndexRangeCount(returnType ListReturnType, index *FilterExpression, count *FilterExpression, ...) *FilterExpression

+ func ExpListGetByRank(returnType ListReturnType, value_type ExpType, rank *FilterExpression, ...) *FilterExpression

+ func ExpListGetByRankRange(returnType ListReturnType, rank *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListGetByRankRangeCount(returnType ListReturnType, rank *FilterExpression, count *FilterExpression, ...) *FilterExpression

+ func ExpListGetByValue(returnType ListReturnType, value *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListGetByValueList(returnType ListReturnType, values *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListGetByValueRange(returnType ListReturnType, value_begin *FilterExpression, ...) *FilterExpression

+ func ExpListGetByValueRelativeRankRange(returnType ListReturnType, value *FilterExpression, rank *FilterExpression, ...) *FilterExpression

+ func ExpListGetByValueRelativeRankRangeCount(returnType ListReturnType, value *FilterExpression, rank *FilterExpression, ...) *FilterExpression

+ func ExpListIncrement(policy *ListPolicy, index *FilterExpression, value *FilterExpression, ...) *FilterExpression

+ func ExpListInsert(policy *ListPolicy, index *FilterExpression, value *FilterExpression, ...) *FilterExpression

+ func ExpListInsertItems(policy *ListPolicy, index *FilterExpression, list *FilterExpression, ...) *FilterExpression

+ func ExpListRemoveByIndex(index *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListRemoveByIndexRange(index *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListRemoveByIndexRangeCount(index *FilterExpression, count *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListRemoveByRank(rank *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListRemoveByRankRange(rank *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListRemoveByRankRangeCount(rank *FilterExpression, count *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListRemoveByValue(value *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListRemoveByValueList(values *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListRemoveByValueRange(value_begin *FilterExpression, value_end *FilterExpression, ...) *FilterExpression

+ func ExpListRemoveByValueRelativeRankRange(value *FilterExpression, rank *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpListRemoveByValueRelativeRankRangeCount(value *FilterExpression, rank *FilterExpression, count *FilterExpression, ...) *FilterExpression

+ func ExpListSet(policy *ListPolicy, index *FilterExpression, value *FilterExpression, ...) *FilterExpression

+ func ExpListSize(bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListSort(sort_flags ListSortFlags, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpListVal(val ...Value) *FilterExpression

+ func ExpListValueVal(val ...interface{}) *FilterExpression

+ func ExpMapBin(name string) *FilterExpression

+ func ExpMapClear(bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapGetByIndex(return_type mapReturnType, value_type ExpType, index *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByIndexRange(return_type mapReturnType, index *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByIndexRangeCount(return_type mapReturnType, index *FilterExpression, count *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByKey(return_type mapReturnType, value_type ExpType, key *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByKeyList(return_type mapReturnType, keys *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByKeyRange(return_type mapReturnType, key_begin *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByKeyRelativeIndexRange(return_type mapReturnType, key *FilterExpression, index *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByKeyRelativeIndexRangeCount(return_type mapReturnType, key *FilterExpression, index *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByRank(return_type mapReturnType, value_type ExpType, rank *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByRankRange(return_type mapReturnType, rank *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByRankRangeCount(return_type mapReturnType, rank *FilterExpression, count *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByValue(return_type mapReturnType, value *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByValueList(return_type mapReturnType, values *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByValueRange(return_type mapReturnType, value_begin *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByValueRelativeRankRange(return_type mapReturnType, value *FilterExpression, rank *FilterExpression, ...) *FilterExpression

+ func ExpMapGetByValueRelativeRankRangeCount(return_type mapReturnType, value *FilterExpression, rank *FilterExpression, ...) *FilterExpression

+ func ExpMapIncrement(policy *MapPolicy, key *FilterExpression, incr *FilterExpression, ...) *FilterExpression

+ func ExpMapPut(policy *MapPolicy, key *FilterExpression, value *FilterExpression, ...) *FilterExpression

+ func ExpMapPutItems(policy *MapPolicy, amap *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapRemoveByIndex(index *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapRemoveByIndexRange(index *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapRemoveByIndexRangeCount(index *FilterExpression, count *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapRemoveByKey(key *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapRemoveByKeyList(keys *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapRemoveByKeyRange(key_begin *FilterExpression, key_end *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapRemoveByKeyRelativeIndexRange(key *FilterExpression, index *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapRemoveByKeyRelativeIndexRangeCount(key *FilterExpression, index *FilterExpression, count *FilterExpression, ...) *FilterExpression

+ func ExpMapRemoveByRank(rank *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapRemoveByRankRange(rank *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapRemoveByRankRangeCount(rank *FilterExpression, count *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapRemoveByValue(value *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapRemoveByValueList(values *FilterExpression, bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapRemoveByValueRange(value_begin *FilterExpression, value_end *FilterExpression, ...) *FilterExpression

+ func ExpMapRemoveByValueRelativeRankRange(value *FilterExpression, rank *FilterExpression, bin *FilterExpression, ...) *FilterExpression

+ func ExpMapRemoveByValueRelativeRankRangeCount(value *FilterExpression, rank *FilterExpression, count *FilterExpression, ...) *FilterExpression

+ func ExpMapSize(bin *FilterExpression, ctx ...*CDTContext) *FilterExpression

+ func ExpMapVal(val MapValue) *FilterExpression

+ func ExpNilValue() *FilterExpression

+ func ExpNot(exp *FilterExpression) *FilterExpression

+ func ExpNotEq(left *FilterExpression, right *FilterExpression) *FilterExpression

+ func ExpOr(exps ...*FilterExpression) *FilterExpression

+ func ExpRegexCompare(regex string, flags ExpRegexFlags, bin *FilterExpression) *FilterExpression

+ func ExpSetName() *FilterExpression

+ func ExpSinceUpdate() *FilterExpression

+ func ExpStringBin(name string) *FilterExpression

+ func ExpStringVal(val string) *FilterExpression

+ func ExpTTL() *FilterExpression

+ func ExpValueArrayVal(val ValueArray) *FilterExpression

+ func ExpVoidTime() *FilterExpression

+ type FloatValue float64

+ func NewFloatValue(value float64) FloatValue

+ func (vl FloatValue) EstimateSize() (int, error)

+ func (vl FloatValue) GetObject() interface{}

+ func (vl FloatValue) GetType() int

+ func (vl FloatValue) String() string

+ type GenerationPolicy int

+ const EXPECT_GEN_EQUAL

+ const EXPECT_GEN_GT

+ const NONE

+ type GeoJSONValue string

+ func NewGeoJSONValue(value string) GeoJSONValue

+ func (vl GeoJSONValue) EstimateSize() (int, error)

+ func (vl GeoJSONValue) GetObject() interface{}

+ func (vl GeoJSONValue) GetType() int

+ func (vl GeoJSONValue) String() string

+ type HLLPolicy struct

+ func DefaultHLLPolicy() *HLLPolicy

+ func NewHLLPolicy(flags int) *HLLPolicy

+ type HLLValue []byte

+ func NewHLLValue(bytes []byte) HLLValue

+ func (vl HLLValue) EstimateSize() (int, error)

+ func (vl HLLValue) GetObject() interface{}

+ func (vl HLLValue) GetType() int

+ func (vl HLLValue) String() string

+ type Host struct

+ Name string

+ Port int

+ TLSName string

+ func NewHost(name string, port int) *Host

+ func (h *Host) String() string

+ type IndexCollectionType int

+ const ICT_DEFAULT

+ const ICT_LIST

+ const ICT_MAPKEYS

+ const ICT_MAPVALUES

+ type IndexTask struct

+ func NewIndexTask(cluster *Cluster, namespace string, indexName string) *IndexTask

+ func (tski *IndexTask) IsDone() (bool, error)

+ func (tski *IndexTask) OnComplete() chan error

+ type IndexType string

+ const GEO2DSPHERE

+ const NUMERIC

+ const STRING

+ type InfinityValue struct

+ func NewInfinityValue() InfinityValue

+ func (vl InfinityValue) EstimateSize() (int, error)

+ func (vl InfinityValue) GetObject() interface{}

+ func (vl InfinityValue) GetType() int

+ func (vl InfinityValue) String() string

+ type InfoPolicy struct

+ Timeout time.Duration

+ func NewInfoPolicy() *InfoPolicy

+ type IntegerValue int

+ func NewIntegerValue(value int) IntegerValue

+ func (vl IntegerValue) EstimateSize() (int, error)

+ func (vl IntegerValue) GetObject() interface{}

+ func (vl IntegerValue) GetType() int

+ func (vl IntegerValue) String() string

+ type JsonValue map[string]interface

+ func (vl JsonValue) EstimateSize() (int, error)

+ func (vl JsonValue) GetObject() interface{}

+ func (vl JsonValue) GetType() int

+ func (vl JsonValue) String() string

+ func NewJsonValue(vmap map[string]interface{}) JsonValue

+ type Key struct

+ func NewKey(namespace string, setName string, key interface{}) (*Key, error)

+ func NewKeyWithDigest(namespace string, setName string, key interface{}, digest []byte) (*Key, error)

+ func (ky *Key) Digest() []byte

+ func (ky *Key) Equals(other *Key) bool

+ func (ky *Key) Namespace() string

+ func (ky *Key) SetDigest(digest []byte) error

+ func (ky *Key) SetName() string

+ func (ky *Key) SetValue(val Value) error

+ func (ky *Key) String() string

+ func (ky *Key) Value() Value

+ type Language string

+ const LUA

+ type ListIter interface

+ Len func() int

+ PackList func(buf BufferEx) (int, error)

+ type ListOrderType int

+ const ListOrderOrdered

+ const ListOrderUnordered

+ type ListPolicy struct

+ func DefaultListPolicy() *ListPolicy

+ func NewListPolicy(order ListOrderType, flags int) *ListPolicy

+ type ListReturnType int

+ const ListReturnTypeCount

+ const ListReturnTypeIndex

+ const ListReturnTypeInverted

+ const ListReturnTypeNone

+ const ListReturnTypeRank

+ const ListReturnTypeReverseIndex

+ const ListReturnTypeReverseRank

+ const ListReturnTypeValue

+ type ListSortFlags int

+ const ListSortFlagsDefault

+ const ListSortFlagsDescending

+ const ListSortFlagsDropDuplicates

+ type ListValue []interface

+ func (vl ListValue) EstimateSize() (int, error)

+ func (vl ListValue) GetObject() interface{}

+ func (vl ListValue) GetType() int

+ func (vl ListValue) String() string

+ func NewListValue(list []interface{}) ListValue

+ type ListerValue struct

+ func NewListerValue(list ListIter) *ListerValue

+ func (vl *ListerValue) EstimateSize() (int, error)

+ func (vl *ListerValue) GetObject() interface{}

+ func (vl *ListerValue) GetType() int

+ func (vl *ListerValue) String() string

+ type LongValue int64

+ func NewLongValue(value int64) LongValue

+ func (vl LongValue) EstimateSize() (int, error)

+ func (vl LongValue) GetObject() interface{}

+ func (vl LongValue) GetType() int

+ func (vl LongValue) String() string

+ type MapIter interface

+ Len func() int

+ PackMap func(buf BufferEx) (int, error)

+ type MapPair struct

+ Key interface{}

+ Value interface{}

+ type MapPolicy struct

+ func DefaultMapPolicy() *MapPolicy

+ func NewMapPolicy(order mapOrderType, writeMode *mapWriteMode) *MapPolicy

+ func NewMapPolicyWithFlags(order mapOrderType, flags int) *MapPolicy

+ type MapValue map[interface{}]interface

+ func (vl MapValue) EstimateSize() (int, error)

+ func (vl MapValue) GetObject() interface{}

+ func (vl MapValue) GetType() int

+ func (vl MapValue) String() string

+ func NewMapValue(vmap map[interface{}]interface{}) MapValue

+ type MapperValue struct

+ func NewMapperValue(vmap MapIter) *MapperValue

+ func (vl *MapperValue) EstimateSize() (int, error)

+ func (vl *MapperValue) GetObject() interface{}

+ func (vl *MapperValue) GetType() int

+ func (vl *MapperValue) String() string

+ type MultiPolicy struct

+ FailOnClusterChange bool

+ IncludeBinData bool

+ MaxConcurrentNodes int

+ RecordQueueSize int

+ RecordsPerSecond int

+ func NewMultiPolicy() *MultiPolicy

+ type Node struct

+ func GetNodeBatchRead(cluster *Cluster, key *Key, replica ReplicaPolicy, replicaSC ReplicaPolicy, ...) (*Node, error)

+ func (nd *Node) Close()

+ func (nd *Node) Equals(other *Node) bool

+ func (nd *Node) GetAliases() []*Host

+ func (nd *Node) GetConnection(timeout time.Duration) (conn *Connection, err error)

+ func (nd *Node) GetHost() *Host

+ func (nd *Node) GetName() string

+ func (nd *Node) InvalidateConnection(conn *Connection)

+ func (nd *Node) IsActive() bool

+ func (nd *Node) MigrationInProgress() (bool, error)

+ func (nd *Node) PutConnection(conn *Connection)

+ func (nd *Node) Rack(namespace string) (int, error)

+ func (nd *Node) Refresh(peers *peers) error

+ func (nd *Node) RequestInfo(policy *InfoPolicy, name ...string) (map[string]string, error)

+ func (nd *Node) String() string

+ func (nd *Node) WaitUntillMigrationIsFinished(timeout time.Duration) (err error)

+ func (nd *Node) WarmUp(count int) (int, error)

+ func (node *Node) RequestStats(policy *InfoPolicy) (map[string]string, error)

+ type NodeError struct

+ func (ne *NodeError) Err() error

+ func (ne *NodeError) Error() string

+ func (ne *NodeError) Node() *Node

+ type NullValue struct

+ func NewNullValue() NullValue

+ func (vl NullValue) EstimateSize() (int, error)

+ func (vl NullValue) GetObject() interface{}

+ func (vl NullValue) GetType() int

+ func (vl NullValue) String() string

+ type Operation struct

+ func AddOp(bin *Bin) *Operation

+ func AppendOp(bin *Bin) *Operation

+ func BitAddOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, value int64, ...) *Operation

+ func BitAndOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, value []byte, ...) *Operation

+ func BitCountOp(binName string, bitOffset int, bitSize int, ctx ...*CDTContext) *Operation

+ func BitGetIntOp(binName string, bitOffset int, bitSize int, signed bool, ctx ...*CDTContext) *Operation

+ func BitGetOp(binName string, bitOffset int, bitSize int, ctx ...*CDTContext) *Operation

+ func BitInsertOp(policy *BitPolicy, binName string, byteOffset int, value []byte, ...) *Operation

+ func BitLScanOp(binName string, bitOffset int, bitSize int, value bool, ctx ...*CDTContext) *Operation

+ func BitLShiftOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, shift int, ...) *Operation

+ func BitNotOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, ...) *Operation

+ func BitOrOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, value []byte, ...) *Operation

+ func BitRScanOp(binName string, bitOffset int, bitSize int, value bool, ctx ...*CDTContext) *Operation

+ func BitRShiftOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, shift int, ...) *Operation

+ func BitRemoveOp(policy *BitPolicy, binName string, byteOffset int, byteSize int, ...) *Operation

+ func BitResizeOp(policy *BitPolicy, binName string, byteSize int, resizeFlags BitResizeFlags, ...) *Operation

+ func BitSetIntOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, value int64, ...) *Operation

+ func BitSetOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, value []byte, ...) *Operation

+ func BitSubtractOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, value int64, ...) *Operation

+ func BitXorOp(policy *BitPolicy, binName string, bitOffset int, bitSize int, value []byte, ...) *Operation

+ func DeleteOp() *Operation

+ func GetHeaderOp() *Operation

+ func GetOp() *Operation

+ func GetOpForBin(binName string) *Operation

+ func HLLAddOp(policy *HLLPolicy, binName string, list []Value, ...) *Operation

+ func HLLDescribeOp(binName string) *Operation

+ func HLLFoldOp(binName string, indexBitCount int) *Operation

+ func HLLGetCountOp(binName string) *Operation

+ func HLLGetIntersectCountOp(binName string, list []HLLValue) *Operation

+ func HLLGetSimilarityOp(binName string, list []HLLValue) *Operation

+ func HLLGetUnionCountOp(binName string, list []HLLValue) *Operation

+ func HLLGetUnionOp(binName string, list []HLLValue) *Operation

+ func HLLInitOp(policy *HLLPolicy, binName string, indexBitCount, minHashBitCount int) *Operation

+ func HLLRefreshCountOp(binName string) *Operation

+ func HLLSetUnionOp(policy *HLLPolicy, binName string, list []HLLValue) *Operation

+ func ListAppendOp(binName string, values ...interface{}) *Operation

+ func ListAppendWithPolicyContextOp(policy *ListPolicy, binName string, ctx []*CDTContext, values ...interface{}) *Operation

+ func ListAppendWithPolicyOp(policy *ListPolicy, binName string, values ...interface{}) *Operation

+ func ListClearOp(binName string, ctx ...*CDTContext) *Operation

+ func ListCreateOp(binName string, listOrder ListOrderType, pad bool, ctx ...*CDTContext) *Operation

+ func ListGetByIndexOp(binName string, index int, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListGetByIndexRangeCountOp(binName string, index, count int, returnType ListReturnType, ...) *Operation

+ func ListGetByIndexRangeOp(binName string, index int, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListGetByRankOp(binName string, rank int, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListGetByRankRangeCountOp(binName string, rank, count int, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListGetByRankRangeOp(binName string, rank int, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListGetByValueListOp(binName string, values []interface{}, returnType ListReturnType, ...) *Operation

+ func ListGetByValueOp(binName string, value interface{}, returnType ListReturnType, ...) *Operation

+ func ListGetByValueRangeOp(binName string, beginValue, endValue interface{}, returnType ListReturnType, ...) *Operation

+ func ListGetByValueRelativeRankRangeCountOp(binName string, value interface{}, rank, count int, returnType ListReturnType, ...) *Operation

+ func ListGetByValueRelativeRankRangeOp(binName string, value interface{}, rank int, returnType ListReturnType, ...) *Operation

+ func ListGetOp(binName string, index int, ctx ...*CDTContext) *Operation

+ func ListGetRangeFromOp(binName string, index int, ctx ...*CDTContext) *Operation

+ func ListGetRangeOp(binName string, index int, count int, ctx ...*CDTContext) *Operation

+ func ListIncrementByOneOp(binName string, index int, ctx ...*CDTContext) *Operation

+ func ListIncrementByOneWithPolicyOp(policy *ListPolicy, binName string, index int, ctx ...*CDTContext) *Operation

+ func ListIncrementOp(binName string, index int, value interface{}, ctx ...*CDTContext) *Operation

+ func ListIncrementWithPolicyOp(policy *ListPolicy, binName string, index int, value interface{}, ...) *Operation

+ func ListInsertOp(binName string, index int, values ...interface{}) *Operation

+ func ListInsertWithPolicyContextOp(policy *ListPolicy, binName string, index int, ctx []*CDTContext, ...) *Operation

+ func ListInsertWithPolicyOp(policy *ListPolicy, binName string, index int, values ...interface{}) *Operation

+ func ListPopOp(binName string, index int, ctx ...*CDTContext) *Operation

+ func ListPopRangeFromOp(binName string, index int, ctx ...*CDTContext) *Operation

+ func ListPopRangeOp(binName string, index int, count int, ctx ...*CDTContext) *Operation

+ func ListRemoveByIndexOp(binName string, index int, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListRemoveByIndexRangeCountOp(binName string, index, count int, returnType ListReturnType, ...) *Operation

+ func ListRemoveByIndexRangeOp(binName string, index, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListRemoveByRankOp(binName string, rank int, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListRemoveByRankRangeCountOp(binName string, rank int, count int, returnType ListReturnType, ...) *Operation

+ func ListRemoveByRankRangeOp(binName string, rank int, returnType ListReturnType, ctx ...*CDTContext) *Operation

+ func ListRemoveByValueListOp(binName string, values []interface{}, returnType ListReturnType, ...) *Operation

+ func ListRemoveByValueOp(binName string, value interface{}, returnType ListReturnType, ...) *Operation

+ func ListRemoveByValueRangeOp(binName string, returnType ListReturnType, valueBegin, valueEnd interface{}, ...) *Operation

+ func ListRemoveByValueRelativeRankRangeCountOp(binName string, returnType ListReturnType, value interface{}, rank, count int, ...) *Operation

+ func ListRemoveByValueRelativeRankRangeOp(binName string, returnType ListReturnType, value interface{}, rank int, ...) *Operation

+ func ListRemoveOp(binName string, index int, ctx ...*CDTContext) *Operation

+ func ListRemoveRangeFromOp(binName string, index int, ctx ...*CDTContext) *Operation

+ func ListRemoveRangeOp(binName string, index int, count int, ctx ...*CDTContext) *Operation

+ func ListSetOp(binName string, index int, value interface{}, ctx ...*CDTContext) *Operation

+ func ListSetOrderOp(binName string, listOrder ListOrderType, ctx ...*CDTContext) *Operation

+ func ListSizeOp(binName string, ctx ...*CDTContext) *Operation

+ func ListSortOp(binName string, sortFlags ListSortFlags, ctx ...*CDTContext) *Operation

+ func ListTrimOp(binName string, index int, count int, ctx ...*CDTContext) *Operation

+ func MapClearOp(binName string, ctx ...*CDTContext) *Operation

+ func MapCreateOp(binName string, order mapOrderType, ctx []*CDTContext) *Operation

+ func MapDecrementOp(policy *MapPolicy, binName string, key interface{}, decr interface{}, ...) *Operation

+ func MapGetByIndexOp(binName string, index int, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapGetByIndexRangeCountOp(binName string, index int, count int, returnType mapReturnType, ...) *Operation

+ func MapGetByIndexRangeOp(binName string, index int, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapGetByKeyListOp(binName string, keys []interface{}, returnType mapReturnType, ...) *Operation

+ func MapGetByKeyOp(binName string, key interface{}, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapGetByKeyRangeOp(binName string, keyBegin interface{}, keyEnd interface{}, ...) *Operation

+ func MapGetByKeyRelativeIndexRangeCountOp(binName string, key interface{}, index, count int, returnType mapReturnType, ...) *Operation

+ func MapGetByKeyRelativeIndexRangeOp(binName string, key interface{}, index int, returnType mapReturnType, ...) *Operation

+ func MapGetByRankOp(binName string, rank int, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapGetByRankRangeCountOp(binName string, rank int, count int, returnType mapReturnType, ...) *Operation

+ func MapGetByRankRangeOp(binName string, rank int, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapGetByValueListOp(binName string, values []interface{}, returnType mapReturnType, ...) *Operation

+ func MapGetByValueOp(binName string, value interface{}, returnType mapReturnType, ...) *Operation

+ func MapGetByValueRangeOp(binName string, valueBegin interface{}, valueEnd interface{}, ...) *Operation

+ func MapGetByValueRelativeRankRangeCountOp(binName string, value interface{}, rank, count int, returnType mapReturnType, ...) *Operation

+ func MapGetByValueRelativeRankRangeOp(binName string, value interface{}, rank int, returnType mapReturnType, ...) *Operation

+ func MapIncrementOp(policy *MapPolicy, binName string, key interface{}, incr interface{}, ...) *Operation

+ func MapPutItemsOp(policy *MapPolicy, binName string, amap map[interface{}]interface{}, ...) *Operation

+ func MapPutOp(policy *MapPolicy, binName string, key interface{}, value interface{}, ...) *Operation

+ func MapRemoveByIndexOp(binName string, index int, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapRemoveByIndexRangeCountOp(binName string, index int, count int, returnType mapReturnType, ...) *Operation

+ func MapRemoveByIndexRangeOp(binName string, index int, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapRemoveByKeyListOp(binName string, keys []interface{}, returnType mapReturnType, ...) *Operation

+ func MapRemoveByKeyOp(binName string, key interface{}, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapRemoveByKeyRangeOp(binName string, keyBegin interface{}, keyEnd interface{}, ...) *Operation

+ func MapRemoveByKeyRelativeIndexRangeCountOp(binName string, key interface{}, index, count int, returnType mapReturnType, ...) *Operation

+ func MapRemoveByKeyRelativeIndexRangeOp(binName string, key interface{}, index int, returnType mapReturnType, ...) *Operation

+ func MapRemoveByRankOp(binName string, rank int, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapRemoveByRankRangeCountOp(binName string, rank int, count int, returnType mapReturnType, ...) *Operation

+ func MapRemoveByRankRangeOp(binName string, rank int, returnType mapReturnType, ctx ...*CDTContext) *Operation

+ func MapRemoveByValueListOp(binName string, values []interface{}, returnType mapReturnType, ...) *Operation

+ func MapRemoveByValueOp(binName string, value interface{}, returnType mapReturnType, ...) *Operation

+ func MapRemoveByValueRangeOp(binName string, valueBegin interface{}, valueEnd interface{}, ...) *Operation

+ func MapRemoveByValueRelativeRankRangeCountOp(binName string, value interface{}, rank, count int, returnType mapReturnType, ...) *Operation

+ func MapRemoveByValueRelativeRankRangeOp(binName string, value interface{}, rank int, returnType mapReturnType, ...) *Operation

+ func MapSetPolicyOp(policy *MapPolicy, binName string, ctx ...*CDTContext) *Operation

+ func MapSizeOp(binName string, ctx ...*CDTContext) *Operation

+ func PrependOp(bin *Bin) *Operation

+ func PutOp(bin *Bin) *Operation

+ func TouchOp() *Operation

+ type OperationType *struct{ op byte }

+ type Partition struct

+ Namespace string

+ PartitionId int

+ func NewPartition(partitions *Partitions, key *Key, replica ReplicaPolicy, linearize bool) *Partition

+ func PartitionForRead(cluster *Cluster, policy *BasePolicy, key *Key) (*Partition, error)

+ func PartitionForWrite(cluster *Cluster, policy *BasePolicy, key *Key) (*Partition, error)

+ func (ptn *Partition) Equals(other *Partition) bool

+ func (ptn *Partition) GetNodeRead(cluster *Cluster) (*Node, error)

+ func (ptn *Partition) GetNodeWrite(cluster *Cluster) (*Node, error)

+ func (ptn *Partition) PrepareRetryRead(isClientTimeout bool)

+ func (ptn *Partition) PrepareRetryWrite(isClientTimeout bool)

+ func (ptn *Partition) String() string

+ type Partitions struct

+ Replicas [][]*Node

+ SCMode bool

+ type Policy interface

+ GetBasePolicy func() *BasePolicy

+ type PredExp interface

+ String func() string

+ type Priority int

+ const DEFAULT

+ const HIGH

+ const LOW

+ const MEDIUM

+ type Privilege struct

+ Code privilegeCode

+ Namespace string

+ SetName string

+ type QueryPolicy struct

+ func NewQueryPolicy() *QueryPolicy

+ type ReadModeAP int

+ const ReadModeAPAll

+ const ReadModeAPOne

+ type ReadModeSC int

+ const ReadModeSCAllowReplica

+ const ReadModeSCAllowUnavailable

+ const ReadModeSCLinearize

+ const ReadModeSCSession

+ type Record struct

+ Bins BinMap

+ Expiration uint32

+ Generation uint32

+ Key *Key

+ Node *Node

+ func (rc *Record) String() string

+ type RecordExistsAction int

+ const CREATE_ONLY

+ const REPLACE

+ const REPLACE_ONLY

+ const UPDATE

+ const UPDATE_ONLY

+ type Recordset struct

+ Records chan *Record

+ func (os *Recordset) TaskId() uint64

+ func (rcs *Recordset) Close() error

+ func (rcs *Recordset) IsActive() bool

+ func (rcs *Recordset) Read() (record *Record, err error)

+ func (rcs *Recordset) Results() <-chan *Result

+ type RegisterTask struct

+ func NewRegisterTask(cluster *Cluster, packageName string) *RegisterTask

+ func (tskr *RegisterTask) IsDone() (bool, error)

+ func (tskr *RegisterTask) OnComplete() chan error

+ type RemoveTask struct

+ func NewRemoveTask(cluster *Cluster, packageName string) *RemoveTask

+ func (tskr *RemoveTask) IsDone() (bool, error)

+ func (tskr *RemoveTask) OnComplete() chan error

+ type ReplicaPolicy int

+ const MASTER

+ const MASTER_PROLES

+ const PREFER_RACK

+ const RANDOM

+ const SEQUENCE

+ func GetReplicaPolicySC(policy *BasePolicy) ReplicaPolicy

+ type Result struct

+ Err error

+ Record *Record

+ func (res *Result) String() string

+ type Role struct

+ Name string

+ Privileges []Privilege

+ Whitelist []string

+ type ScanPolicy struct

+ ConcurrentNodes bool

+ ScanPercent int

+ func NewScanPolicy() *ScanPolicy

+ type Statement struct

+ BinNames []string

+ Filter *Filter

+ IndexName string

+ Namespace string

+ SetName string

+ TaskId uint64

+ func NewStatement(ns string, set string, binNames ...string) *Statement

+ func (stmt *Statement) IsScan() bool

+ func (stmt *Statement) SetAggregateFunction(packageName string, functionName string, functionArgs []Value, returnData bool)

+ func (stmt *Statement) SetFilter(filter *Filter) error

+ func (stmt *Statement) SetPredExp(predexp ...PredExp) error

+ type StringValue string

+ func NewStringValue(value string) StringValue

+ func (vl StringValue) EstimateSize() (int, error)

+ func (vl StringValue) GetObject() interface{}

+ func (vl StringValue) GetType() int

+ func (vl StringValue) String() string

+ type Task interface

+ IsDone func() (bool, error)

+ OnComplete func() chan error

+ type UDF struct

+ Filename string

+ Hash string

+ Language Language

+ type UserRoles struct

+ Roles []string

+ User string

+ type Value interface

+ EstimateSize func() (int, error)

+ GetObject func() interface{}

+ GetType func() int

+ String func() string

+ func NewValue(v interface{}) Value

+ type ValueArray []Value

+ func NewValueArray(array []Value) *ValueArray

+ func (va ValueArray) EstimateSize() (int, error)

+ func (va ValueArray) GetObject() interface{}

+ func (va ValueArray) GetType() int

+ func (va ValueArray) String() string

+ type WildCardValue struct

+ func NewWildCardValue() WildCardValue

+ func (vl WildCardValue) EstimateSize() (int, error)

+ func (vl WildCardValue) GetObject() interface{}

+ func (vl WildCardValue) GetType() int

+ func (vl WildCardValue) String() string

+ type WritePolicy struct

+ CommitLevel CommitLevel

+ DurableDelete bool

+ Expiration uint32

+ Generation uint32

+ GenerationPolicy GenerationPolicy

+ RecordExistsAction RecordExistsAction

+ RespondPerEachOp bool

+ func NewWritePolicy(generation, expiration uint32) *WritePolicy

Other modules containing this package

gopkg.in/aerospike/aerospike-client-go.v1

gopkg.in/aerospike/aerospike-client-go.v2

gopkg.in/aerospike/aerospike-client-go.v3

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL