aerospike

package module

Go to main page

Versions in this module

v7

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