aerospike

package module

Go to main page

Versions in this module

v7

v7.7.3

Nov 29, 2024

v7.7.2

Nov 1, 2024

v7.7.1

Sep 23, 2024

v7.7.0

Sep 13, 2024

retracted

v7.6.1

Aug 12, 2024

v7.6.0

Jul 22, 2024

v7.5.0

Jul 1, 2024

Changes in this version

type ProxyClient

+ func (clnt *ProxyClient) RequestInfo(policy *InfoPolicy, commands ...string) (map[string]string, Error)

v7.4.0

May 20, 2024

Changes in this version

type Client

+ func (clnt *Client) GetDefaultBatchReadPolicy() *BatchReadPolicy

+ func (clnt *Client) SetDefaultBatchReadPolicy(policy *BatchReadPolicy)

type ProxyClient

+ func (clnt *ProxyClient) GetDefaultBatchReadPolicy() *BatchReadPolicy

+ func (clnt *ProxyClient) SetDefaultBatchReadPolicy(policy *BatchReadPolicy)

v7.3.0

May 8, 2024

retracted

Changes in this version

+ var MinBufferSize = 8 * 1024

+ var PoolCutOffBufferSize = 1024 * 1024

type BatchDelete

+ Policy *BatchDeletePolicy

type BatchUDF

+ FunctionArgs []Value

+ FunctionName string

+ PackageName string

+ Policy *BatchUDFPolicy

type BatchWrite

+ Ops []*Operation

+ Policy *BatchWritePolicy

type Client

+ DefaultBatchReadPolicy *BatchReadPolicy

+ func (clnt *Client) DisableMetrics()

+ func (clnt *Client) EnableMetrics(policy *MetricsPolicy)

+ func (clnt *Client) MetricsEnabled() bool

type Cluster

+ func (clstr *Cluster) DisableMetrics()

+ func (clstr *Cluster) EnableMetrics(policy *MetricsPolicy)

+ func (clstr *Cluster) MetricsEnabled() bool

+ func (clstr *Cluster) MetricsPolicy() *MetricsPolicy

+ type MetricsPolicy struct

+ HistogramType histogram.Type

+ LatencyBase int

+ LatencyColumns int

+ func DefaultMetricsPolicy() *MetricsPolicy

type ProxyClient

+ DefaultBatchReadPolicy *BatchReadPolicy

v7.2.1

Apr 10, 2024

v7.2.0

Mar 28, 2024

Changes in this version

+ const LONG

+ const LONG_RELAX_AP

+ const SHORT

type BasePolicy

+ ReadTouchTTLPercent int32

type BatchReadPolicy

+ ReadTouchTTLPercent int32

type CDTContext

+ Id int

+ Value Value

type Filter

+ func NewFilter(name string, indexCollectionType IndexCollectionType, valueParticleType int, ...) *Filter

type MultiPolicy

+ RawCDT bool

type Operation

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

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

+ type QueryDuration int

type QueryPolicy

+ ExpectedDuration QueryDuration

+ type RawBlobValue struct

+ Data []byte

+ ParticleType int

+ func NewRawBlobValue(pt int, b []byte) *RawBlobValue

+ func (vl *RawBlobValue) EstimateSize() (int, Error)

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

+ func (vl *RawBlobValue) GetType() int

+ func (vl *RawBlobValue) String() string

type Result

+ BVal *int64

type Statement

+ ReturnData bool

v7.1.0

Jan 25, 2024

v7.0.0

Dec 14, 2023

Changes in this version

+ 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 MapWriteFlagsCreateOnly

+ const MapWriteFlagsDefault

+ const MapWriteFlagsNoFail

+ const MapWriteFlagsPartial

+ const MapWriteFlagsUpdateOnly

+ const Read

+ const ReadWrite

+ const ReadWriteUDF

+ const SIndexAdmin

+ const SysAdmin

+ const TTLDontExpire

+ const TTLDontUpdate

+ const TTLServerDefault

+ const Truncate

+ const UDFAdmin

+ const UserAdmin

+ const Write

+ var DefaultBufferSize = 64 * 1024

+ var ErrClusterIsEmpty = newConstError(types.INVALID_NODE_ERROR, "cluster is empty")

+ var ErrConnectionPoolEmpty = newConstError(types.NO_AVAILABLE_CONNECTIONS_TO_NODE, ...)

+ var ErrConnectionPoolExhausted = newConstError(types.NO_AVAILABLE_CONNECTIONS_TO_NODE, ...)

+ var ErrFilteredOut = newConstError(types.FILTERED_OUT)

+ var ErrInvalidObjectType = newConstError(types.SERIALIZE_ERROR, ...)

+ var ErrInvalidParam = newConstError(types.PARAMETER_ERROR)

+ var ErrInvalidPartitionMap = newConstError(types.INVALID_CLUSTER_PARTITION_MAP, ...)

+ var ErrInvalidUser = newConstError(types.INVALID_USER)

+ var ErrKeyNotFound = newConstError(types.KEY_NOT_FOUND_ERROR)

+ var ErrLuaPoolEmpty = newConstError(types.COMMON_ERROR, "Error fetching a lua instance from pool")

+ var ErrMaxRetriesExceeded = newConstError(types.MAX_RETRIES_EXCEEDED, ...)

+ var ErrNetTimeout = newConstError(types.TIMEOUT, "network timeout")

+ var ErrNetwork = newConstError(types.NETWORK_ERROR)

+ var ErrNoBinNamesAllowedInQueryExecute = newConstError(types.INVALID_COMMAND, "`Statement.BinNames` must be empty for QueryExecute")

+ var ErrNoOperationsSpecified = newConstError(types.INVALID_COMMAND, "no operations were passed to QueryExecute")

+ var ErrNotAuthenticated = newConstError(types.NOT_AUTHENTICATED)

+ var ErrPartitionScanQueryNotSupported = newConstError(types.PARAMETER_ERROR, ...)

+ var ErrQueryTerminated = newConstError(types.QUERY_TERMINATED)

+ var ErrRecordsetClosed = newConstError(types.RECORDSET_CLOSED)

+ var ErrScanTerminated = newConstError(types.SCAN_TERMINATED)

+ var ErrServerNotAvailable = newConstError(types.SERVER_NOT_AVAILABLE)

+ var ErrTimeout = newConstError(types.TIMEOUT, "command execution timed out on client: See `Policy.Timeout`")

+ var ErrTooManyConnectionsForNode = newConstError(types.NO_AVAILABLE_CONNECTIONS_TO_NODE, ...)

+ var ErrTooManyOpeningConnections = newConstError(types.NO_AVAILABLE_CONNECTIONS_TO_NODE, ...)

+ var ErrUDFBadResponse = newConstError(types.UDF_BAD_RESPONSE, "invalid UDF return value")

+ var MapOrder = struct{ ... }

+ var MapReturnType = struct{ ... }

+ var MapWriteMode = struct{ ... }

+ var MaxBufferSize = 1024 * 1024 * 120

+ var UseNativeBoolTypeInReflection = false

+ func Base64ToCDTContext(b64 string) ([]*CDTContext, Error)

+ func CreateClientWithPolicyAndHost(typ ClientType, policy *ClientPolicy, hosts ...*Host) (ClientIfc, Error)

+ func ExpFromBase64(str string) (*Expression, Error)

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

+ func GetNodeBatchWrite(cluster *Cluster, key *Key, replica ReplicaPolicy, prevNode *Node, ...) (*Node, Error)

+ func KeepConnection(err Error) bool

+ 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 NewCluster(policy *ClientPolicy, hosts []*Host) (*Cluster, Error)

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

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

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

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

+ func NewProxyClientWithPolicyAndHost(policy *ClientPolicy, host *Host, dialOptions ...grpc.DialOption) (*ProxyClient, Error)

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

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

+ func SetAerospikeTag(tag string)

+ func SetLuaPath(lpath string)

+ type AdminCommand struct

+ func NewAdminCommand(buf []byte) *AdminCommand

+ func (acmd *AdminCommand) QueryRole(conn *Connection, policy *AdminPolicy, roleName string) (*Role, Error)

+ func (acmd *AdminCommand) QueryRoles(conn *Connection, policy *AdminPolicy) ([]*Role, Error)

+ func (acmd *AdminCommand) QueryUser(conn *Connection, policy *AdminPolicy, user string) (*UserRoles, Error)

+ func (acmd *AdminCommand) QueryUsers(conn *Connection, policy *AdminPolicy) ([]*UserRoles, Error)

+ type AdminPolicy struct

+ Timeout time.Duration

+ func NewAdminPolicy() *AdminPolicy

+ type AerospikeBlob interface

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

+ type AerospikeError struct

+ InDoubt bool

+ Iteration int

+ Node *Node

+ ResultCode types.ResultCode

+ func (ase *AerospikeError) As(target interface{}) bool

+ func (ase *AerospikeError) Error() string

+ func (ase *AerospikeError) Is(e error) bool

+ func (ase *AerospikeError) IsInDoubt() bool

+ func (ase *AerospikeError) Matches(rcs ...types.ResultCode) bool

+ func (ase *AerospikeError) Trace() string

+ func (ase *AerospikeError) Unwrap() error

+ type AuthMode int

+ const AuthModeExternal

+ const AuthModeInternal

+ const AuthModePKI

+ type BasePolicy struct

+ ExitFastOnExhaustedConnectionPool bool

+ FilterExpression *Expression

+ MaxRetries int

+ 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 BatchDelete struct

+ func NewBatchDelete(policy *BatchDeletePolicy, key *Key) *BatchDelete

+ type BatchDeletePolicy struct

+ CommitLevel CommitLevel

+ DurableDelete bool

+ FilterExpression *Expression

+ Generation uint32

+ GenerationPolicy GenerationPolicy

+ SendKey bool

+ func NewBatchDeletePolicy() *BatchDeletePolicy

+ type BatchPolicy struct

+ AllowInline bool

+ AllowInlineSSD bool

+ AllowPartialResults bool

+ ConcurrentNodes int

+ RespondAllKeys bool

+ func NewBatchPolicy() *BatchPolicy

+ func NewReadBatchPolicy() *BatchPolicy

+ func NewWriteBatchPolicy() *BatchPolicy

+ type BatchRead struct

+ BinNames []string

+ Ops []*Operation

+ Policy *BatchReadPolicy

+ ReadAllBins bool

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

+ func NewBatchReadHeader(policy *BatchReadPolicy, key *Key) *BatchRead

+ func NewBatchReadOps(policy *BatchReadPolicy, key *Key, ops ...*Operation) *BatchRead

+ func (br *BatchRead) String() string

+ type BatchReadPolicy struct

+ FilterExpression *Expression

+ ReadModeAP ReadModeAP

+ ReadModeSC ReadModeSC

+ func NewBatchReadPolicy() *BatchReadPolicy

+ type BatchRecord struct

+ Err Error

+ InDoubt bool

+ Key *Key

+ Record *Record

+ ResultCode types.ResultCode

+ func (br *BatchRecord) BatchRec() *BatchRecord

+ func (br *BatchRecord) String() string

+ type BatchRecordIfc interface

+ BatchRec func() *BatchRecord

+ String func() string

+ type BatchUDF struct

+ func NewBatchUDF(policy *BatchUDFPolicy, key *Key, packageName, functionName string, ...) *BatchUDF

+ type BatchUDFPolicy struct

+ CommitLevel CommitLevel

+ DurableDelete bool

+ Expiration uint32

+ FilterExpression *Expression

+ SendKey bool

+ func NewBatchUDFPolicy() *BatchUDFPolicy

+ type BatchWrite struct

+ func NewBatchWrite(policy *BatchWritePolicy, key *Key, ops ...*Operation) *BatchWrite

+ type BatchWritePolicy struct

+ CommitLevel CommitLevel

+ DurableDelete bool

+ Expiration uint32

+ FilterExpression *Expression

+ Generation uint32

+ GenerationPolicy GenerationPolicy

+ RecordExistsAction RecordExistsAction

+ SendKey bool

+ func NewBatchWritePolicy() *BatchWritePolicy

+ 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 BoolValue bool

+ func (vb BoolValue) EstimateSize() (int, Error)

+ func (vb BoolValue) GetObject() interface{}

+ func (vb BoolValue) GetType() int

+ func (vb BoolValue) String() string

+ type BufferEx interface

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

+ WriteBool func(b bool) int

+ WriteByte func(b byte)

+ WriteFloat32 func(float float32) int

+ WriteFloat64 func(float float64) int

+ WriteInt16 func(num int16) int

+ WriteInt32 func(num int32) int

+ WriteInt64 func(num int64) int

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

+ WriteUint16 func(num uint16) int

+ WriteUint32 func(num uint32) int

+ WriteUint64 func(num uint64) int

+ 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

+ func (ctx *CDTContext) String() string

+ type Client struct

+ DefaultAdminPolicy *AdminPolicy

+ DefaultBatchDeletePolicy *BatchDeletePolicy

+ DefaultBatchPolicy *BatchPolicy

+ DefaultBatchUDFPolicy *BatchUDFPolicy

+ DefaultBatchWritePolicy *BatchWritePolicy

+ DefaultInfoPolicy *InfoPolicy

+ DefaultPolicy *BasePolicy

+ DefaultQueryPolicy *QueryPolicy

+ DefaultScanPolicy *ScanPolicy

+ DefaultWritePolicy *WritePolicy

+ 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) BatchDelete(policy *BatchPolicy, deletePolicy *BatchDeletePolicy, keys []*Key) ([]*BatchRecord, Error)

+ func (clnt *Client) BatchExecute(policy *BatchPolicy, udfPolicy *BatchUDFPolicy, keys []*Key, ...) ([]*BatchRecord, 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) BatchGetOperate(policy *BatchPolicy, keys []*Key, ops ...*Operation) ([]*Record, Error)

+ func (clnt *Client) BatchOperate(policy *BatchPolicy, records []BatchRecordIfc) 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) GetDefaultAdminPolicy() *AdminPolicy

+ func (clnt *Client) GetDefaultBatchDeletePolicy() *BatchDeletePolicy

+ func (clnt *Client) GetDefaultBatchPolicy() *BatchPolicy

+ func (clnt *Client) GetDefaultBatchUDFPolicy() *BatchUDFPolicy

+ func (clnt *Client) GetDefaultBatchWritePolicy() *BatchWritePolicy

+ func (clnt *Client) GetDefaultInfoPolicy() *InfoPolicy

+ func (clnt *Client) GetDefaultPolicy() *BasePolicy

+ func (clnt *Client) GetDefaultQueryPolicy() *QueryPolicy

+ func (clnt *Client) GetDefaultScanPolicy() *ScanPolicy

+ func (clnt *Client) GetDefaultWritePolicy() *WritePolicy

+ 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) QueryPartitionObjects(policy *QueryPolicy, statement *Statement, objChan interface{}, ...) (*Recordset, Error)

+ func (clnt *Client) QueryPartitions(policy *QueryPolicy, statement *Statement, partitionFilter *PartitionFilter) (*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) ScanPartitionObjects(apolicy *ScanPolicy, objChan interface{}, partitionFilter *PartitionFilter, ...) (*Recordset, Error)

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

+ func (clnt *Client) SetDefaultAdminPolicy(policy *AdminPolicy)

+ func (clnt *Client) SetDefaultBatchDeletePolicy(policy *BatchDeletePolicy)

+ func (clnt *Client) SetDefaultBatchPolicy(policy *BatchPolicy)

+ func (clnt *Client) SetDefaultBatchUDFPolicy(policy *BatchUDFPolicy)

+ func (clnt *Client) SetDefaultBatchWritePolicy(policy *BatchWritePolicy)

+ func (clnt *Client) SetDefaultInfoPolicy(policy *InfoPolicy)

+ func (clnt *Client) SetDefaultPolicy(policy *BasePolicy)

+ func (clnt *Client) SetDefaultQueryPolicy(policy *QueryPolicy)

+ func (clnt *Client) SetDefaultScanPolicy(policy *ScanPolicy)

+ func (clnt *Client) SetDefaultWritePolicy(policy *WritePolicy)

+ func (clnt *Client) SetQuotas(policy *AdminPolicy, roleName string, readQuota, writeQuota uint32) Error

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

+ func (clnt *Client) SetXDRFilter(policy *InfoPolicy, datacenter string, namespace string, filter *Expression) 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 *InfoPolicy, namespace, set string, beforeLastUpdate *time.Time) Error

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

+ type ClientIfc interface

+ Add func(policy *WritePolicy, key *Key, binMap BinMap) Error

+ AddBins func(policy *WritePolicy, key *Key, bins ...*Bin) Error

+ Append func(policy *WritePolicy, key *Key, binMap BinMap) Error

+ AppendBins func(policy *WritePolicy, key *Key, bins ...*Bin) Error

+ BatchDelete func(policy *BatchPolicy, deletePolicy *BatchDeletePolicy, keys []*Key) ([]*BatchRecord, Error)

+ BatchExecute func(policy *BatchPolicy, udfPolicy *BatchUDFPolicy, keys []*Key, ...) ([]*BatchRecord, Error)

+ BatchExists func(policy *BatchPolicy, keys []*Key) ([]bool, Error)

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

+ BatchGetComplex func(policy *BatchPolicy, records []*BatchRead) Error

+ BatchGetHeader func(policy *BatchPolicy, keys []*Key) ([]*Record, Error)

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

+ BatchGetOperate func(policy *BatchPolicy, keys []*Key, ops ...*Operation) ([]*Record, Error)

+ BatchOperate func(policy *BatchPolicy, records []BatchRecordIfc) Error

+ ChangePassword func(policy *AdminPolicy, user string, password string) Error

+ Close func()

+ Cluster func() *Cluster

+ CreateComplexIndex func(policy *WritePolicy, namespace string, setName string, indexName string, ...) (*IndexTask, Error)

+ CreateIndex func(policy *WritePolicy, namespace string, setName string, indexName string, ...) (*IndexTask, Error)

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

+ CreateUser func(policy *AdminPolicy, user string, password string, roles []string) Error

+ Delete func(policy *WritePolicy, key *Key) (bool, Error)

+ DropIndex func(policy *WritePolicy, namespace string, setName string, indexName string) Error

+ DropRole func(policy *AdminPolicy, roleName string) Error

+ DropUser func(policy *AdminPolicy, user string) Error

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

+ ExecuteUDF func(policy *QueryPolicy, statement *Statement, packageName string, ...) (*ExecuteTask, Error)

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

+ Exists func(policy *BasePolicy, key *Key) (bool, Error)

+ Get func(policy *BasePolicy, key *Key, binNames ...string) (*Record, Error)

+ GetDefaultAdminPolicy func() *AdminPolicy

+ GetDefaultBatchDeletePolicy func() *BatchDeletePolicy

+ GetDefaultBatchPolicy func() *BatchPolicy

+ GetDefaultBatchUDFPolicy func() *BatchUDFPolicy

+ GetDefaultBatchWritePolicy func() *BatchWritePolicy

+ GetDefaultInfoPolicy func() *InfoPolicy

+ GetDefaultPolicy func() *BasePolicy

+ GetDefaultQueryPolicy func() *QueryPolicy

+ GetDefaultScanPolicy func() *ScanPolicy

+ GetDefaultWritePolicy func() *WritePolicy

+ GetHeader func(policy *BasePolicy, key *Key) (*Record, Error)

+ GetNodeNames func() []string

+ GetNodes func() []*Node

+ GetObject func(policy *BasePolicy, key *Key, obj interface{}) Error

+ GrantPrivileges func(policy *AdminPolicy, roleName string, privileges []Privilege) Error

+ GrantRoles func(policy *AdminPolicy, user string, roles []string) Error

+ IsConnected func() bool

+ ListUDF func(policy *BasePolicy) ([]*UDF, Error)

+ Operate func(policy *WritePolicy, key *Key, operations ...*Operation) (*Record, Error)

+ Prepend func(policy *WritePolicy, key *Key, binMap BinMap) Error

+ PrependBins func(policy *WritePolicy, key *Key, bins ...*Bin) Error

+ Put func(policy *WritePolicy, key *Key, binMap BinMap) Error

+ PutBins func(policy *WritePolicy, key *Key, bins ...*Bin) Error

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

+ Query func(policy *QueryPolicy, statement *Statement) (*Recordset, Error)

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

+ QueryExecute func(policy *QueryPolicy, writePolicy *WritePolicy, statement *Statement, ...) (*ExecuteTask, Error)

+ QueryNode func(policy *QueryPolicy, node *Node, statement *Statement) (*Recordset, Error)

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

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

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

+ QueryPartitions func(policy *QueryPolicy, statement *Statement, partitionFilter *PartitionFilter) (*Recordset, Error)

+ QueryRole func(policy *AdminPolicy, role string) (*Role, Error)

+ QueryRoles func(policy *AdminPolicy) ([]*Role, Error)

+ QueryUser func(policy *AdminPolicy, user string) (*UserRoles, Error)

+ QueryUsers func(policy *AdminPolicy) ([]*UserRoles, Error)

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

+ RegisterUDFFromFile func(policy *WritePolicy, clientPath string, serverPath string, language Language) (*RegisterTask, Error)

+ RemoveUDF func(policy *WritePolicy, udfName string) (*RemoveTask, Error)

+ RevokePrivileges func(policy *AdminPolicy, roleName string, privileges []Privilege) Error

+ RevokeRoles func(policy *AdminPolicy, user string, roles []string) Error

+ ScanAll func(apolicy *ScanPolicy, namespace string, setName string, binNames ...string) (*Recordset, Error)

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

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

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

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

+ ScanPartitions func(apolicy *ScanPolicy, partitionFilter *PartitionFilter, namespace string, ...) (*Recordset, Error)

+ SetDefaultAdminPolicy func(*AdminPolicy)

+ SetDefaultBatchDeletePolicy func(*BatchDeletePolicy)

+ SetDefaultBatchPolicy func(*BatchPolicy)

+ SetDefaultBatchUDFPolicy func(*BatchUDFPolicy)

+ SetDefaultBatchWritePolicy func(*BatchWritePolicy)

+ SetDefaultInfoPolicy func(*InfoPolicy)

+ SetDefaultPolicy func(*BasePolicy)

+ SetDefaultQueryPolicy func(*QueryPolicy)

+ SetDefaultScanPolicy func(*ScanPolicy)

+ SetDefaultWritePolicy func(*WritePolicy)

+ SetQuotas func(policy *AdminPolicy, roleName string, readQuota, writeQuota uint32) Error

+ SetWhitelist func(policy *AdminPolicy, roleName string, whitelist []string) Error

+ SetXDRFilter func(policy *InfoPolicy, datacenter string, namespace string, filter *Expression) Error

+ Stats func() (map[string]interface{}, Error)

+ String func() string

+ Touch func(policy *WritePolicy, key *Key) Error

+ Truncate func(policy *InfoPolicy, namespace, set string, beforeLastUpdate *time.Time) Error

+ WarmUp func(count int) (int, Error)

+ type ClientPolicy struct

+ AuthMode AuthMode

+ ClusterName string

+ ConnectionQueueSize int

+ ErrorRateWindow int

+ FailIfNotConnected bool

+ IdleTimeout time.Duration

+ IgnoreOtherSubnetAliases bool

+ IpMap map[string]string

+ LimitConnectionsToQueueSize bool

+ LoginTimeout time.Duration

+ MaxErrorRate int

+ MinConnectionsPerNode int

+ OpeningConnectionThreshold int

+ Password string

+ RackAware bool

+ RackIds []int

+ SeedOnlyCluster bool

+ TendInterval time.Duration

+ Timeout time.Duration

+ TlsConfig *tls.Config

+ UseServicesAlternate bool

+ User string

+ func NewClientPolicy() *ClientPolicy

+ func (cp *ClientPolicy) RequiresAuthentication() bool

+ type ClientType int

+ const CTNative

+ const CTProxy

+ type Cluster struct

+ 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) GetSeedCount() int

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

+ func (clstr *Cluster) Healthy() Error

+ 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) Error

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

+ type CommitLevel int

+ const COMMIT_ALL

+ const COMMIT_MASTER

+ type Connection struct

+ 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, aerr Error)

+ func (ctn *Connection) RequestInfo(names ...string) (map[string]string, Error)

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

+ func (ctn *Connection) Write(buf []byte) (total int, aerr 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 Error interface

+ IsInDoubt func() bool

+ Matches func(rcs ...types.ResultCode) bool

+ Trace func() string

+ Unwrap func() error

+ func CDTContextToBase64(ctxl []*CDTContext) (string, Error)

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

+ type ExecuteTask struct

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

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

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

+ func (etsk *ExecuteTask) TaskId() uint64

+ type ExpReadFlags int

+ const ExpReadFlagDefault

+ const ExpReadFlagEvalNoFail

+ 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 ExpWriteFlags int

+ const ExpWriteFlagAllowDelete

+ const ExpWriteFlagCreateOnly

+ const ExpWriteFlagDefault

+ const ExpWriteFlagEvalNoFail

+ const ExpWriteFlagPolicyNoFail

+ const ExpWriteFlagUpdateOnly

+ type Expression struct

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

+ func ExpBinExists(name string) *Expression

+ func ExpBinType(name string) *Expression

+ func ExpBitAdd(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBitAnd(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBitCount(bitOffset *Expression, bitSize *Expression, bin *Expression) *Expression

+ func ExpBitGet(bitOffset *Expression, bitSize *Expression, bin *Expression) *Expression

+ func ExpBitGetInt(bitOffset *Expression, bitSize *Expression, signed bool, bin *Expression) *Expression

+ func ExpBitInsert(policy *BitPolicy, byteOffset *Expression, value *Expression, bin *Expression) *Expression

+ func ExpBitLScan(bitOffset *Expression, bitSize *Expression, value *Expression, bin *Expression) *Expression

+ func ExpBitLShift(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBitNot(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, bin *Expression) *Expression

+ func ExpBitOr(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBitRScan(bitOffset *Expression, bitSize *Expression, value *Expression, bin *Expression) *Expression

+ func ExpBitRShift(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBitRemove(policy *BitPolicy, byteOffset *Expression, byteSize *Expression, ...) *Expression

+ func ExpBitResize(policy *BitPolicy, byteSize *Expression, resizeFlags BitResizeFlags, ...) *Expression

+ func ExpBitSet(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBitSetInt(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBitSubtract(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBitXor(policy *BitPolicy, bitOffset *Expression, bitSize *Expression, ...) *Expression

+ func ExpBlobBin(name string) *Expression

+ func ExpBlobVal(val []byte) *Expression

+ func ExpBoolBin(name string) *Expression

+ func ExpBoolVal(val bool) *Expression

+ func ExpCond(exps ...*Expression) *Expression

+ func ExpDef(name string, value *Expression) *Expression

+ func ExpDeviceSize() *Expression

+ func ExpDigestModulo(modulo int64) *Expression

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

+ func ExpExclusive(exps ...*Expression) *Expression

+ func ExpFloatBin(name string) *Expression

+ func ExpFloatVal(val float64) *Expression

+ func ExpGeoBin(name string) *Expression

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

+ func ExpGeoVal(val string) *Expression

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

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

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

+ func ExpHLLAddWithIndex(policy *HLLPolicy, list *Expression, indexBitCount *Expression, ...) *Expression

+ func ExpHLLAddWithIndexAndMinHash(policy *HLLPolicy, list *Expression, indexBitCount *Expression, ...) *Expression

+ func ExpHLLBin(name string) *Expression

+ func ExpHLLDescribe(bin *Expression) *Expression

+ func ExpHLLGetCount(bin *Expression) *Expression

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

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

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

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

+ func ExpHLLInit(policy *HLLPolicy, indexBitCount *Expression, bin *Expression) *Expression

+ func ExpHLLInitWithMinHash(policy *HLLPolicy, indexBitCount *Expression, minHashCount *Expression, ...) *Expression

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

+ func ExpInfinityValue() *Expression

+ func ExpIntARShift(value *Expression, shift *Expression) *Expression

+ func ExpIntAnd(exps ...*Expression) *Expression

+ func ExpIntBin(name string) *Expression

+ func ExpIntCount(exp *Expression) *Expression

+ func ExpIntLScan(value *Expression, search *Expression) *Expression

+ func ExpIntLShift(value *Expression, shift *Expression) *Expression

+ func ExpIntNot(exp *Expression) *Expression

+ func ExpIntOr(exps ...*Expression) *Expression

+ func ExpIntRScan(value *Expression, search *Expression) *Expression

+ func ExpIntRShift(value *Expression, shift *Expression) *Expression

+ func ExpIntVal(val int64) *Expression

+ func ExpIntXor(exps ...*Expression) *Expression

+ func ExpIsTombstone() *Expression

+ func ExpKey(expType ExpType) *Expression

+ func ExpKeyExists() *Expression

+ func ExpLastUpdate() *Expression

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

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

+ func ExpLet(exps ...*Expression) *Expression

+ func ExpListAppend(policy *ListPolicy, value *Expression, bin *Expression, ctx ...*CDTContext) *Expression

+ func ExpListAppendItems(policy *ListPolicy, list *Expression, bin *Expression, ctx ...*CDTContext) *Expression

+ func ExpListBin(name string) *Expression

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

+ func ExpListGetByIndex(returnType ListReturnType, valueType ExpType, index *Expression, ...) *Expression

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

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

+ func ExpListGetByRank(returnType ListReturnType, valueType ExpType, rank *Expression, ...) *Expression

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

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

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

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

+ func ExpListGetByValueRange(returnType ListReturnType, valueBegin *Expression, valueEnd *Expression, ...) *Expression

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

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

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

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

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

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

+ func ExpListRemoveByIndexRange(returnType ListReturnType, index *Expression, bin *Expression, ...) *Expression

+ func ExpListRemoveByIndexRangeCount(returnType ListReturnType, index *Expression, count *Expression, ...) *Expression

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

+ func ExpListRemoveByRankRange(returnType ListReturnType, rank *Expression, bin *Expression, ...) *Expression

+ func ExpListRemoveByRankRangeCount(returnType ListReturnType, rank *Expression, count *Expression, ...) *Expression

+ func ExpListRemoveByValue(returnType ListReturnType, value *Expression, bin *Expression, ...) *Expression

+ func ExpListRemoveByValueList(returnType ListReturnType, values *Expression, bin *Expression, ...) *Expression

+ func ExpListRemoveByValueRange(returnType ListReturnType, valueBegin *Expression, valueEnd *Expression, ...) *Expression

+ func ExpListRemoveByValueRelativeRankRange(returnType ListReturnType, value *Expression, rank *Expression, ...) *Expression

+ func ExpListRemoveByValueRelativeRankRangeCount(returnType ListReturnType, value *Expression, rank *Expression, ...) *Expression

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

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

+ func ExpListSort(sortFlags ListSortFlags, bin *Expression, ctx ...*CDTContext) *Expression

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

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

+ func ExpMapBin(name string) *Expression

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

+ func ExpMapGetByIndex(returnType MapReturnTypes, valueType ExpType, index *Expression, ...) *Expression

+ func ExpMapGetByIndexRange(returnType MapReturnTypes, index *Expression, bin *Expression, ...) *Expression

+ func ExpMapGetByIndexRangeCount(returnType MapReturnTypes, index *Expression, count *Expression, ...) *Expression

+ func ExpMapGetByKey(returnType MapReturnTypes, valueType ExpType, key *Expression, bin *Expression, ...) *Expression

+ func ExpMapGetByKeyList(returnType MapReturnTypes, keys *Expression, bin *Expression, ...) *Expression

+ func ExpMapGetByKeyRange(returnType MapReturnTypes, keyBegin *Expression, keyEnd *Expression, ...) *Expression

+ func ExpMapGetByKeyRelativeIndexRange(returnType MapReturnTypes, key *Expression, index *Expression, bin *Expression, ...) *Expression

+ func ExpMapGetByKeyRelativeIndexRangeCount(returnType MapReturnTypes, key *Expression, index *Expression, ...) *Expression

+ func ExpMapGetByRank(returnType MapReturnTypes, valueType ExpType, rank *Expression, ...) *Expression

+ func ExpMapGetByRankRange(returnType MapReturnTypes, rank *Expression, bin *Expression, ...) *Expression

+ func ExpMapGetByRankRangeCount(returnType MapReturnTypes, rank *Expression, count *Expression, ...) *Expression

+ func ExpMapGetByValue(returnType MapReturnTypes, value *Expression, bin *Expression, ...) *Expression

+ func ExpMapGetByValueList(returnType MapReturnTypes, values *Expression, bin *Expression, ...) *Expression

+ func ExpMapGetByValueRange(returnType MapReturnTypes, valueBegin *Expression, valueEnd *Expression, ...) *Expression

+ func ExpMapGetByValueRelativeRankRange(returnType MapReturnTypes, value *Expression, rank *Expression, ...) *Expression

+ func ExpMapGetByValueRelativeRankRangeCount(returnType MapReturnTypes, value *Expression, rank *Expression, ...) *Expression

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

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

+ func ExpMapPutItems(policy *MapPolicy, amap *Expression, bin *Expression, ctx ...*CDTContext) *Expression

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

+ func ExpMapRemoveByIndexRange(returnType MapReturnTypes, index *Expression, bin *Expression, ...) *Expression

+ func ExpMapRemoveByIndexRangeCount(returnType MapReturnTypes, index *Expression, count *Expression, ...) *Expression

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

+ func ExpMapRemoveByKeyList(returnType MapReturnTypes, keys *Expression, bin *Expression, ...) *Expression

+ func ExpMapRemoveByKeyRange(returnType MapReturnTypes, keyBegin *Expression, keyEnd *Expression, ...) *Expression

+ func ExpMapRemoveByKeyRelativeIndexRange(returnType MapReturnTypes, key *Expression, index *Expression, bin *Expression, ...) *Expression

+ func ExpMapRemoveByKeyRelativeIndexRangeCount(returnType MapReturnTypes, key *Expression, index *Expression, ...) *Expression

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

+ func ExpMapRemoveByRankRange(returnType MapReturnTypes, rank *Expression, bin *Expression, ...) *Expression

+ func ExpMapRemoveByRankRangeCount(returnType MapReturnTypes, rank *Expression, count *Expression, ...) *Expression

+ func ExpMapRemoveByValue(returnType MapReturnTypes, value *Expression, bin *Expression, ...) *Expression

+ func ExpMapRemoveByValueList(returnType MapReturnTypes, values *Expression, bin *Expression, ...) *Expression

+ func ExpMapRemoveByValueRange(returnType MapReturnTypes, valueBegin *Expression, valueEnd *Expression, ...) *Expression

+ func ExpMapRemoveByValueRelativeRankRange(returnType MapReturnTypes, value *Expression, rank *Expression, ...) *Expression

+ func ExpMapRemoveByValueRelativeRankRangeCount(returnType MapReturnTypes, value *Expression, rank *Expression, ...) *Expression

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

+ func ExpMapVal(val MapValue) *Expression

+ func ExpMax(exps ...*Expression) *Expression

+ func ExpMemorySize() *Expression

+ func ExpMin(exps ...*Expression) *Expression

+ func ExpNilValue() *Expression

+ func ExpNot(exp *Expression) *Expression

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

+ func ExpNumAbs(value *Expression) *Expression

+ func ExpNumAdd(exps ...*Expression) *Expression

+ func ExpNumCeil(num *Expression) *Expression

+ func ExpNumDiv(exps ...*Expression) *Expression

+ func ExpNumFloor(num *Expression) *Expression

+ func ExpNumLog(num *Expression, base *Expression) *Expression

+ func ExpNumMod(numerator *Expression, denominator *Expression) *Expression

+ func ExpNumMul(exps ...*Expression) *Expression

+ func ExpNumPow(base *Expression, exponent *Expression) *Expression

+ func ExpNumSub(exps ...*Expression) *Expression

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

+ func ExpRecordSize() *Expression

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

+ func ExpSetName() *Expression

+ func ExpSinceUpdate() *Expression

+ func ExpStringBin(name string) *Expression

+ func ExpStringVal(val string) *Expression

+ func ExpTTL() *Expression

+ func ExpToFloat(num *Expression) *Expression

+ func ExpToInt(num *Expression) *Expression

+ func ExpUnknown() *Expression

+ func ExpValueArrayVal(val ValueArray) *Expression

+ func ExpVar(name string) *Expression

+ func ExpVoidTime() *Expression

+ func ExpWildCardValue() *Expression

+ func (fe *Expression) Base64() (string, Error)

+ type ExpressionArgument interface

+ type FieldType int

+ const BATCH_INDEX

+ const BATCH_INDEX_WITH_SET

+ const BVAL_ARRAY

+ const DIGEST_ARRAY

+ const DIGEST_RIPE

+ const DIGEST_RIPE_ARRAY

+ const FILTER_EXP

+ const INDEX_CONTEXT

+ const INDEX_NAME

+ const INDEX_RANGE

+ const INDEX_TYPE

+ const KEY

+ const MAX_RECORDS

+ const NAMESPACE

+ const PID_ARRAY

+ const QUERY_BINLIST

+ const RECORDS_PER_SECOND

+ const SCAN_OPTIONS

+ const SOCKET_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{}, ctx ...*CDTContext) *Filter

+ func NewGeoRegionsContainingPointFilter(binName, point string, ctx ...*CDTContext) *Filter

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

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

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

+ func NewGeoWithinRegionFilter(binName, region string, ctx ...*CDTContext) *Filter

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

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

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

+ func (fltr *Filter) IndexCollectionType() IndexCollectionType

+ func (fltr *Filter) String() string

+ 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

+ func (ict IndexCollectionType) String() string

+ 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 BLOB

+ 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 (ky *Key) Digest() []byte

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

+ func (ky *Key) Namespace() string

+ func (ky *Key) PartitionId() int

+ 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 ListReturnTypeExists

+ 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 MapOrderTypes = mapOrderType

+ 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

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

+ type MapReturnTypes = mapReturnType

+ 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 MapWriteModes = mapWriteMode

+ 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

+ IncludeBinData bool

+ MaxConcurrentNodes int

+ MaxRecords int64

+ RecordQueueSize int

+ RecordsPerSecond int

+ func NewMultiPolicy() *MultiPolicy

+ type Node struct

+ 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) PartitionGeneration() int

+ func (nd *Node) PeersGeneration() int

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

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

+ func (nd *Node) RebalanceGeneration() int

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

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

+ func (nd *Node) RequestStats(policy *InfoPolicy) (map[string]string, Error)

+ func (nd *Node) String() string

+ func (nd *Node) SupportsBatchAny() bool

+ func (nd *Node) SupportsPartitionQuery() bool

+ func (nd *Node) SupportsQueryShow() bool

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

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

+ 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 OpResults []interface

+ 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 ExpReadOp(name string, exp *Expression, flags ExpReadFlags) *Operation

+ func ExpWriteOp(binName string, exp *Expression, flags ExpWriteFlags) *Operation

+ func GetBinOp(binName string) *Operation

+ func GetHeaderOp() *Operation

+ func GetOp() *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 int, 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 ListSetWithPolicyOp(policy *ListPolicy, binName string, index int, value interface{}, ...) *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 MapCreateWithIndexOp(binName string, order mapOrderType) *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

+ type Partition struct

+ Namespace string

+ PartitionId int

+ func NewPartition(partitions *Partitions, key *Key, replica ReplicaPolicy, prevNode *Node, ...) *Partition

+ func NewPartitionForReplicaPolicy(namespace string, replica ReplicaPolicy) *Partition

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

+ func (ptn *Partition) GetNodeQuery(cluster *Cluster, partitions *Partitions, ps *PartitionStatus) (*Node, Error)

+ 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 PartitionFilter struct

+ Begin int

+ Count int

+ Digest []byte

+ Done bool

+ Partitions []*PartitionStatus

+ Retry bool

+ func NewPartitionFilterAll() *PartitionFilter

+ func NewPartitionFilterById(partitionId int) *PartitionFilter

+ func NewPartitionFilterByKey(key *Key) *PartitionFilter

+ func NewPartitionFilterByRange(begin, count int) *PartitionFilter

+ func (pf *PartitionFilter) DecodeCursor(b []byte) Error

+ func (pf *PartitionFilter) EncodeCursor() ([]byte, Error)

+ func (pf *PartitionFilter) IsDone() bool

+ type PartitionStatus struct

+ BVal int64

+ Digest []byte

+ Id int

+ Retry bool

+ func (ps *PartitionStatus) String() string

+ type Partitions struct

+ Replicas [][]*Node

+ SCMode bool

+ type Policy interface

+ GetBasePolicy func() *BasePolicy

+ type Privilege struct

+ Code privilegeCode

+ Namespace string

+ SetName string

+ type ProxyClient struct

+ DefaultAdminPolicy *AdminPolicy

+ DefaultBatchDeletePolicy *BatchDeletePolicy

+ DefaultBatchPolicy *BatchPolicy

+ DefaultBatchUDFPolicy *BatchUDFPolicy

+ DefaultBatchWritePolicy *BatchWritePolicy

+ DefaultInfoPolicy *InfoPolicy

+ DefaultPolicy *BasePolicy

+ DefaultQueryPolicy *QueryPolicy

+ DefaultScanPolicy *ScanPolicy

+ DefaultWritePolicy *WritePolicy

+ func (clnt *ProxyClient) Add(policy *WritePolicy, key *Key, binMap BinMap) Error

+ func (clnt *ProxyClient) AddBins(policy *WritePolicy, key *Key, bins ...*Bin) Error

+ func (clnt *ProxyClient) Append(policy *WritePolicy, key *Key, binMap BinMap) Error

+ func (clnt *ProxyClient) AppendBins(policy *WritePolicy, key *Key, bins ...*Bin) Error

+ func (clnt *ProxyClient) BatchDelete(policy *BatchPolicy, deletePolicy *BatchDeletePolicy, keys []*Key) ([]*BatchRecord, Error)

+ func (clnt *ProxyClient) BatchExecute(policy *BatchPolicy, udfPolicy *BatchUDFPolicy, keys []*Key, ...) ([]*BatchRecord, Error)

+ func (clnt *ProxyClient) BatchExists(policy *BatchPolicy, keys []*Key) ([]bool, Error)

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

+ func (clnt *ProxyClient) BatchGetComplex(policy *BatchPolicy, records []*BatchRead) Error

+ func (clnt *ProxyClient) BatchGetHeader(policy *BatchPolicy, keys []*Key) ([]*Record, Error)

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

+ func (clnt *ProxyClient) BatchGetOperate(policy *BatchPolicy, keys []*Key, ops ...*Operation) ([]*Record, Error)

+ func (clnt *ProxyClient) BatchOperate(policy *BatchPolicy, records []BatchRecordIfc) Error

+ func (clnt *ProxyClient) ChangePassword(policy *AdminPolicy, user string, password string) Error

+ func (clnt *ProxyClient) Close()

+ func (clnt *ProxyClient) Cluster() *Cluster

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

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

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

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

+ func (clnt *ProxyClient) Delete(policy *WritePolicy, key *Key) (bool, Error)

+ func (clnt *ProxyClient) DropIndex(policy *WritePolicy, namespace string, setName string, indexName string) Error

+ func (clnt *ProxyClient) DropRole(policy *AdminPolicy, roleName string) Error

+ func (clnt *ProxyClient) DropUser(policy *AdminPolicy, user string) Error

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

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

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

+ func (clnt *ProxyClient) Exists(policy *BasePolicy, key *Key) (bool, Error)

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

+ func (clnt *ProxyClient) GetDefaultAdminPolicy() *AdminPolicy

+ func (clnt *ProxyClient) GetDefaultBatchDeletePolicy() *BatchDeletePolicy

+ func (clnt *ProxyClient) GetDefaultBatchPolicy() *BatchPolicy

+ func (clnt *ProxyClient) GetDefaultBatchUDFPolicy() *BatchUDFPolicy

+ func (clnt *ProxyClient) GetDefaultBatchWritePolicy() *BatchWritePolicy

+ func (clnt *ProxyClient) GetDefaultInfoPolicy() *InfoPolicy

+ func (clnt *ProxyClient) GetDefaultPolicy() *BasePolicy

+ func (clnt *ProxyClient) GetDefaultQueryPolicy() *QueryPolicy

+ func (clnt *ProxyClient) GetDefaultScanPolicy() *ScanPolicy

+ func (clnt *ProxyClient) GetDefaultWritePolicy() *WritePolicy

+ func (clnt *ProxyClient) GetHeader(policy *BasePolicy, key *Key) (*Record, Error)

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

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

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

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

+ func (clnt *ProxyClient) GrantRoles(policy *AdminPolicy, user string, roles []string) Error

+ func (clnt *ProxyClient) IsConnected() bool

+ func (clnt *ProxyClient) ListUDF(policy *BasePolicy) ([]*UDF, Error)

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

+ func (clnt *ProxyClient) Prepend(policy *WritePolicy, key *Key, binMap BinMap) Error

+ func (clnt *ProxyClient) PrependBins(policy *WritePolicy, key *Key, bins ...*Bin) Error

+ func (clnt *ProxyClient) Put(policy *WritePolicy, key *Key, binMap BinMap) Error

+ func (clnt *ProxyClient) PutBins(policy *WritePolicy, key *Key, bins ...*Bin) Error

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

+ func (clnt *ProxyClient) Query(policy *QueryPolicy, statement *Statement) (*Recordset, Error)

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

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

+ func (clnt *ProxyClient) QueryNode(policy *QueryPolicy, node *Node, statement *Statement) (*Recordset, Error)

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

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

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

+ func (clnt *ProxyClient) QueryPartitions(policy *QueryPolicy, statement *Statement, partitionFilter *PartitionFilter) (*Recordset, Error)

+ func (clnt *ProxyClient) QueryRole(policy *AdminPolicy, role string) (*Role, Error)

+ func (clnt *ProxyClient) QueryRoles(policy *AdminPolicy) ([]*Role, Error)

+ func (clnt *ProxyClient) QueryUser(policy *AdminPolicy, user string) (*UserRoles, Error)

+ func (clnt *ProxyClient) QueryUsers(policy *AdminPolicy) ([]*UserRoles, Error)

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

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

+ func (clnt *ProxyClient) RemoveUDF(policy *WritePolicy, udfName string) (*RemoveTask, Error)

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

+ func (clnt *ProxyClient) RevokeRoles(policy *AdminPolicy, user string, roles []string) Error

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

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

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

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

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

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

+ func (clnt *ProxyClient) ServerVersion(policy *InfoPolicy) (string, Error)

+ func (clnt *ProxyClient) SetDefaultAdminPolicy(policy *AdminPolicy)

+ func (clnt *ProxyClient) SetDefaultBatchDeletePolicy(policy *BatchDeletePolicy)

+ func (clnt *ProxyClient) SetDefaultBatchPolicy(policy *BatchPolicy)

+ func (clnt *ProxyClient) SetDefaultBatchUDFPolicy(policy *BatchUDFPolicy)

+ func (clnt *ProxyClient) SetDefaultBatchWritePolicy(policy *BatchWritePolicy)

+ func (clnt *ProxyClient) SetDefaultInfoPolicy(policy *InfoPolicy)

+ func (clnt *ProxyClient) SetDefaultPolicy(policy *BasePolicy)

+ func (clnt *ProxyClient) SetDefaultQueryPolicy(policy *QueryPolicy)

+ func (clnt *ProxyClient) SetDefaultScanPolicy(policy *ScanPolicy)

+ func (clnt *ProxyClient) SetDefaultWritePolicy(policy *WritePolicy)

+ func (clnt *ProxyClient) SetQuotas(policy *AdminPolicy, roleName string, readQuota, writeQuota uint32) Error

+ func (clnt *ProxyClient) SetWhitelist(policy *AdminPolicy, roleName string, whitelist []string) Error

+ func (clnt *ProxyClient) SetXDRFilter(policy *InfoPolicy, datacenter string, namespace string, filter *Expression) Error

+ func (clnt *ProxyClient) Stats() (map[string]interface{}, Error)

+ func (clnt *ProxyClient) String() string

+ func (clnt *ProxyClient) Touch(policy *WritePolicy, key *Key) Error

+ func (clnt *ProxyClient) Truncate(policy *InfoPolicy, namespace, set string, beforeLastUpdate *time.Time) Error

+ func (clnt *ProxyClient) WarmUp(count int) (int, Error)

+ type QueryPolicy struct

+ ShortQuery bool

+ 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

+ func (os *Recordset) TaskId() uint64

+ func (rcs *Recordset) Close() Error

+ func (rcs *Recordset) Errors() <-chan Error

+ func (rcs *Recordset) IsActive() bool

+ 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

+ ReadQuota uint32

+ Whitelist []string

+ WriteQuota uint32

+ type ScanPolicy struct

+ 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) String() string

+ 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

+ ConnsInUse int

+ ReadInfo []int

+ Roles []string

+ User string

+ WriteInfo []int

+ 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

github.com/aerospike/aerospike-client-go

github.com/aerospike/aerospike-client-go/v4

github.com/aerospike/aerospike-client-go/v5

github.com/aerospike/aerospike-client-go/v6

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