aerospike

package module
v6.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 7, 2022 License: Apache-2.0 Imports: 35 Imported by: 67

README

Aerospike Go Client v5

Aerospike Client Go Build Status Godoc

An Aerospike library for Go.

This library is compatible with Go 1.13+ and supports the following operating systems: Linux, Mac OS X (Windows builds are possible, but untested).

Up-to-date documentation is available in the Godoc.

You can refer to the test files for idiomatic use cases.

Please refer to CHANGELOG.md for release notes, or if you encounter breaking changes.

Usage

The following is a very simple example of CRUD operations in an Aerospike database.

package main

import (
  "fmt"

  aero "github.com/aerospike/aerospike-client-go/v5"
)

// This is only for this example.
// Please handle errors properly.
func panicOnError(err error) {
  if err != nil {
    panic(err)
  }
}

func main() {
  // define a client to connect to
  client, err := aero.NewClient("127.0.0.1", 3000)
  panicOnError(err)

  key, err := aero.NewKey("test", "aerospike", "key")
  panicOnError(err)

  // define some bins with data
  bins := aero.BinMap{
    "bin1": 42,
    "bin2": "An elephant is a mouse with an operating system",
    "bin3": []interface{}{"Go", 2009},
  }

  // write the bins
  err = client.Put(nil, key, bins)
  panicOnError(err)

  // read it back!
  rec, err := client.Get(nil, key)
  panicOnError(err)

  // delete the key, and check if key exists
  existed, err := client.Delete(nil, key)
  panicOnError(err)
  fmt.Printf("Record existed before delete? %v\n", existed)
}

More examples illustrating the use of the API are located in the examples directory.

Details about the API are available in the docs directory.

Prerequisites

Go version v1.12+ is required.

To install the latest stable version of Go, visit http://golang.org/dl/

Aerospike Go client implements the wire protocol, and does not depend on the C client. It is goroutine friendly, and works asynchronously.

Supported operating systems:

  • Major Linux distributions (Ubuntu, Debian, Red Hat)
  • Mac OS X
  • Windows (untested)

Installation

  1. Install Go 1.13+ and setup your environment as Documented here.
  2. Get the client in your GOPATH : go get github.com/aerospike/aerospike-client-go
  • To update the client library: go get -u github.com/aerospike/aerospike-client-go

Using gopkg.in is also supported: go get -u gopkg.in/aerospike/aerospike-client-go.v1

Some Hints:
  • To run a go program directly: go run <filename.go>
  • to build: go build -o <output> <filename.go>
  • example: go build -o benchmark tools/benchmark/benchmark.go

Performance Tweaking

We are bending all efforts to improve the client's performance. In our reference benchmarks, Go client performs almost as good as the C client.

To read about performance variables, please refer to docs/performance.md

Tests

This library is packaged with a number of tests. Tests require Ginkgo and Gomega library.

Before running the tests, you need to update the dependencies:

$ go get .

To run all the test cases with race detection:

$ ginkgo -r -race

Examples

A variety of example applications are provided in the examples directory.

Tools

A variety of clones of original tools are provided in the tools directory. They show how to use more advanced features of the library to re-implement the same functionality in a more concise way.

Benchmarks

Benchmark utility is provided in the tools/benchmark directory. See the tools/benchmark/README.md for details.

API Documentation

A simple API documentation is available in the docs directory. The latest up-to-date docs can be found in Godoc.

Google App Engine

To build the library for App Engine, build it with the build tag app_engine. Aggregation functionality is not available in this build.

Reflection, and Object API

To make the library both flexible and fast, we had to integrate the reflection API (methods with [Get/Put/...]Object names) tightly in the library. In case you wanted to avoid mixing those API in your app inadvertently, you can use the build tag as_performance to remove those APIs from the build.

License

The Aerospike Go Client is made available under the terms of the Apache License, Version 2, as stated in the file LICENSE.

Individual files may be made available under their own specific license, all compatible with Apache License, Version 2. Please see individual files for details.

Documentation

Overview

Package aerospike provides a client to connect and interact with an Aerospike cluster. This is the official Go implementation of the Aerospike Client.

Index

Examples

Constants

View Source 
const (
	// BitWriteFlagsDefault allows create or update.
	BitWriteFlagsDefault = 0

	// BitWriteFlagsCreateOnly specifies that:
	// If the bin already exists, the operation will be denied.
	// If the bin does not exist, a new bin will be created.
	BitWriteFlagsCreateOnly = 1

	// BitWriteFlagsUpdateOnly specifies that:
	// If the bin already exists, the bin will be overwritten.
	// If the bin does not exist, the operation will be denied.
	BitWriteFlagsUpdateOnly = 2

	// BitWriteFlagsNoFail specifies not to raise error if operation is denied.
	BitWriteFlagsNoFail = 4

	// BitWriteFlagsPartial allows other valid operations to be committed if this operations is
	// denied due to flag constraints.
	BitWriteFlagsPartial = 8
)
View Source 
const (
	// ListWriteFlagsDefault is the default behavior. It means:  Allow duplicate values and insertions at any index.
	ListWriteFlagsDefault = 0
	// ListWriteFlagsAddUnique means: Only add unique values.
	ListWriteFlagsAddUnique = 1
	// ListWriteFlagsInsertBounded means: Enforce list boundaries when inserting.  Do not allow values to be inserted
	// at index outside current list boundaries.
	ListWriteFlagsInsertBounded = 2
	// ListWriteFlagsNoFail means: do not raise error if a list item fails due to write flag constraints.
	ListWriteFlagsNoFail = 4
	// ListWriteFlagsPartial means: allow other valid list items to be committed if a list item fails due to
	// write flag constraints.
	ListWriteFlagsPartial = 8
)
View Source 
const (
	// MapWriteFlagsDefault is the Default. Allow create or update.
	MapWriteFlagsDefault = 0

	// MapWriteFlagsCreateOnly means: If the key already exists, the item will be denied.
	// If the key does not exist, a new item will be created.
	MapWriteFlagsCreateOnly = 1

	// MapWriteFlagsUpdateOnly means: If the key already exists, the item will be overwritten.
	// If the key does not exist, the item will be denied.
	MapWriteFlagsUpdateOnly = 2

	// MapWriteFlagsNoFail means: Do not raise error if a map item is denied due to write flag constraints.
	MapWriteFlagsNoFail = 4

	// MapWriteFlagsNoFail means: Allow other valid map items to be committed if a map item is denied due to
	// write flag constraints.
	MapWriteFlagsPartial = 8
)

*

  • Map write bit flags.
  • Requires server versions >= 4.3.
View Source 
const (
	// HLLWriteFlagsDefault is Default. Allow create or update.
	HLLWriteFlagsDefault = 0

	// HLLWriteFlagsCreateOnly behaves like the following:
	// If the bin already exists, the operation will be denied.
	// If the bin does not exist, a new bin will be created.
	HLLWriteFlagsCreateOnly = 1

	// HLLWriteFlagsUpdateOnly behaves like the following:
	// If the bin already exists, the bin will be overwritten.
	// If the bin does not exist, the operation will be denied.
	HLLWriteFlagsUpdateOnly = 2

	// HLLWriteFlagsNoFail does not raise error if operation is denied.
	HLLWriteFlagsNoFail = 4

	// HLLWriteFlagsAllowFold allows the resulting set to be the minimum of provided index bits.
	// Also, allow the usage of less precise HLL algorithms when minHash bits
	// of all participating sets do not match.
	HLLWriteFlagsAllowFold = 8
)
View Source 
const (
	// UserAdmin allows to manages users and their roles.
	UserAdmin privilegeCode = "user-admin"

	// SysAdmin allows to manage indexes, user defined functions and server configuration.
	SysAdmin privilegeCode = "sys-admin"

	// DataAdmin allows to manage indicies and user defined functions.
	DataAdmin privilegeCode = "data-admin"

	// UDFAdmin allows to manage user defined functions.
	UDFAdmin privilegeCode = "udf-admin"

	// SIndexAdmin allows to manage indicies.
	SIndexAdmin privilegeCode = "sindex-admin"

	// ReadWriteUDF allows read, write and UDF transactions with the database.
	ReadWriteUDF privilegeCode = "read-write-udf"

	// ReadWrite allows read and write transactions with the database.
	ReadWrite privilegeCode = "read-write"

	// Read allows read transactions with the database.
	Read privilegeCode = "read"

	// Write allows write transactions with the database.
	Write privilegeCode = "write"

	// Truncate allow issuing truncate commands.
	Truncate privilegeCode = "truncate"
)

Pre-defined user roles.

View Source 
const (
	// TTLServerDefault will default to namespace configuration variable "default-ttl" on the server.
	TTLServerDefault = 0
	// TTLDontExpire will never expire for Aerospike 2 server versions >= 2.7.2 and Aerospike 3+ server.
	TTLDontExpire = math.MaxUint32
	// TTLDontUpdate will not change the record's ttl when record is written. Supported by Aerospike server versions >= 3.10.1
	TTLDontUpdate = math.MaxUint32 - 1
)

Variables

View Source 
var (
	ErrServerNotAvailable              = newConstError(types.SERVER_NOT_AVAILABLE)
	ErrInvalidPartitionMap             = newConstError(types.INVALID_CLUSTER_PARTITION_MAP, "Partition map errors normally occur when the cluster has partitioned due to network anomaly or node crash, or is not configured properly. Refer to https://www.aerospike.com/docs/operations/configure for more information.")
	ErrKeyNotFound                     = newConstError(types.KEY_NOT_FOUND_ERROR)
	ErrRecordsetClosed                 = newConstError(types.RECORDSET_CLOSED)
	ErrConnectionPoolEmpty             = newConstError(types.NO_AVAILABLE_CONNECTIONS_TO_NODE, "connection pool is empty. This happens when no connections were available")
	ErrConnectionPoolExhausted         = newConstError(types.NO_AVAILABLE_CONNECTIONS_TO_NODE, "Connection pool is exhausted. This happens when all connection are in-use already, and opening more connections is not allowed due to the limits set in policy.ConnectionQueueSize and policy.LimitConnectionsToQueueSize")
	ErrTooManyConnectionsForNode       = newConstError(types.NO_AVAILABLE_CONNECTIONS_TO_NODE, "connection limit reached for this node. This value is controlled via ClientPolicy.LimitConnectionsToQueueSize")
	ErrTooManyOpeningConnections       = newConstError(types.NO_AVAILABLE_CONNECTIONS_TO_NODE, "too many connections are trying to open at once. This value is controlled via ClientPolicy.OpeningConnectionThreshold")
	ErrTimeout                         = newConstError(types.TIMEOUT, "command execution timed out on client: See `Policy.Timeout`")
	ErrNetTimeout                      = newConstError(types.TIMEOUT, "network timeout")
	ErrUDFBadResponse                  = newConstError(types.UDF_BAD_RESPONSE, "invalid UDF return value")
	ErrNoOperationsSpecified           = newConstError(types.INVALID_COMMAND, "no operations were passed to QueryExecute")
	ErrNoBinNamesAllowedInQueryExecute = newConstError(types.INVALID_COMMAND, "`Statement.BinNames` must be empty for QueryExecute")
	ErrFilteredOut                     = newConstError(types.FILTERED_OUT)
	ErrPartitionScanQueryNotSupported  = newConstError(types.PARAMETER_ERROR, "partition Scans/Queries are not supported by all nodes in this cluster")
	ErrScanTerminated                  = newConstError(types.SCAN_TERMINATED)
	ErrQueryTerminated                 = newConstError(types.QUERY_TERMINATED)
	ErrClusterIsEmpty                  = newConstError(types.INVALID_NODE_ERROR, "cluster is empty")
	ErrInvalidUser                     = newConstError(types.INVALID_USER)
	ErrNotAuthenticated                = newConstError(types.NOT_AUTHENTICATED)
	ErrNetwork                         = newConstError(types.NOT_AUTHENTICATED)
	ErrInvalidObjectType               = newConstError(types.SERIALIZE_ERROR, "invalid type for result object. It should be of type struct pointer or addressable")
	ErrMaxRetriesExceeded              = newConstError(types.MAX_RETRIES_EXCEEDED, "command execution timed out on client: Exceeded number of retries. See `Policy.MaxRetries`.")
	ErrInvalidParam                    = newConstError(types.PARAMETER_ERROR)
	ErrLuaPoolEmpty                    = newConstError(types.COMMON_ERROR, "Error fetching a lua instance from pool")
)
View Source 
var DefaultBufferSize = 64 * 1024 // 64 KiB

DefaultBufferSize specifies the initial size of the connection buffer when it is created. If not big enough (as big as the average record), it will be reallocated to size again which will be more expensive.

View Source 
var MapOrder = struct {
	// Map is not ordered. This is the default.
	UNORDERED mapOrderType // 0

	// Order map by key.
	KEY_ORDERED mapOrderType // 1

	// Order map by key, then value.
	KEY_VALUE_ORDERED mapOrderType // 3
}{mapOrderType{0, 0x40}, mapOrderType{1, 0x80}, mapOrderType{3, 0xc0}}

MapOrder defines map storage order.

View Source 
var MapReturnType = struct {
	// NONE will will not return a result.
	NONE mapReturnType

	// INDEX will return key index order.
	//
	// 0 = first key
	// N = Nth key
	// -1 = last key
	INDEX mapReturnType

	// REVERSE_INDEX will return reverse key order.
	//
	// 0 = last key
	// -1 = first key
	REVERSE_INDEX mapReturnType

	// RANK will return value order.
	//
	// 0 = smallest value
	// N = Nth smallest value
	// -1 = largest value
	RANK mapReturnType

	// REVERSE_RANK will return reverse value order.
	//
	// 0 = largest value
	// N = Nth largest value
	// -1 = smallest value
	REVERSE_RANK mapReturnType

	// COUNT will return count of items selected.
	COUNT mapReturnType

	// KEY will return key for single key read and key list for range read.
	KEY mapReturnType

	// VALUE will return value for single key read and value list for range read.
	VALUE mapReturnType

	// KEY_VALUE will return key/value items. The possible return types are:
	//
	// map[interface{}]interface{} : Returned for unordered maps
	// []MapPair : Returned for range results where range order needs to be preserved.
	KEY_VALUE mapReturnType

	// INVERTED will invert meaning of map command and return values.  For example:
	// MapRemoveByKeyRange(binName, keyBegin, keyEnd, MapReturnType.KEY | MapReturnType.INVERTED)
	// With the INVERTED flag enabled, the keys outside of the specified key range will be removed and returned.
	INVERTED mapReturnType
}{
	0, 1, 2, 3, 4, 5, 6, 7, 8, 0x10000,
}

MapReturnType defines the map return type. Type of data to return when selecting or removing items from the map.

View Source 
var MapWriteMode = struct {
	// If the key already exists, the item will be overwritten.
	// If the key does not exist, a new item will be created.
	UPDATE *mapWriteMode

	// If the key already exists, the item will be overwritten.
	// If the key does not exist, the write will fail.
	UPDATE_ONLY *mapWriteMode

	// If the key already exists, the write will fail.
	// If the key does not exist, a new item will be created.
	CREATE_ONLY *mapWriteMode
}{
	&mapWriteMode{cdtMapOpTypePut, cdtMapOpTypePutItems},
	&mapWriteMode{cdtMapOpTypeReplace, cdtMapOpTypeReplaceItems},
	&mapWriteMode{cdtMapOpTypeAdd, cdtMapOpTypeAddItems},
}

MapWriteMode should only be used for server versions < 4.3. MapWriteFlags are recommended for server versions >= 4.3.

View Source 
var (
	// MaxBufferSize protects against allocating massive memory blocks
	// for buffers. Tweak this number if you are returning a lot of
	// LDT elements in your queries.
	MaxBufferSize = 1024 * 1024 * 120 // 120 MB
)
View Source 
var UseNativeBoolTypeInReflection = false

UseNativeBoolTypeInReflection determines if Boolean values should be directly translated to native Boolean type in reflection API introduced in server version 5.6+. By default it keeps the old behavior, but can be set to true to opt in.

Functions

func GetNodeBatchRead 

func GetNodeBatchRead(cluster *Cluster, key *Key, replica ReplicaPolicy, replicaSC ReplicaPolicy, prevNode *Node, sequence int, sequenceSC int) (*Node, Error)

GetNodeBatchRead returns a node for batch reads

func GetNodeBatchWrite 

func GetNodeBatchWrite(cluster *Cluster, key *Key, replica ReplicaPolicy, prevNode *Node, sequence int) (*Node, Error)

GetNodeBatchWrite returns a node for batch Writes

func KeepConnection 

func KeepConnection(err Error) bool

KeepConnection decides if a connection should be kept based on the error type.

func NewClient 

func NewClient(hostname string, port int) (*Client, Error)

NewClient generates a new Client instance.

func NewClientWithPolicy 

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

NewClientWithPolicy generates a new Client using the specified ClientPolicy. If the policy is nil, the default relevant policy will be used.

func NewClientWithPolicyAndHost 

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

NewClientWithPolicyAndHost generates a new Client the specified ClientPolicy and sets up the cluster using the provided hosts. If the policy is nil, the default relevant policy will be used.

func NewCluster 

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

NewCluster generates a Cluster instance.

func NewConnection 

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

NewConnection creates a TLS connection on the network and returns the pointer. A minimum timeout of 2 seconds will always be applied. If the connection is not established in the specified timeout, an error will be returned

func NewHosts 

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

NewHosts initializes new host instances by a passed slice of addresses.

func NewKey 

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

NewKey initializes a key from namespace, optional set name and user key. The set name and user defined key are converted to a digest before sending to the server. The server handles record identifiers by digest only.

func NewKeyWithDigest 

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

NewKeyWithDigest initializes a key from namespace, optional set name and user key. The server handles record identifiers by digest only.

func PartitionForRead 

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

PartitionForRead returns a partition for read purposes

func PartitionForWrite 

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

PartitionForWrite returns a partition for write purposes

func SetAerospikeTag 

func SetAerospikeTag(tag string)

SetAerospikeTag sets the bin tag to the specified tag. This will be useful for when a user wants to use the same tag name for two different concerns. For example, one will be able to use the same tag name for both json and aerospike bin name.

func SetLuaPath 

func SetLuaPath(lpath string)

SetLuaPath sets the Lua interpreter path to files This path is used to load UDFs for QueryAggregate command

Types

type AdminCommand 

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

AdminCommand allows managing user access to the server

func NewAdminCommand 

func NewAdminCommand(buf []byte) *AdminCommand

NewAdminCommand returns an AdminCommand object.

func (*AdminCommand) QueryRole 

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

QueryRole returns role information.

func (*AdminCommand) QueryRoles 

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

QueryRoles returns role information for all roles.

func (*AdminCommand) QueryUser 

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

QueryUser returns user information.

func (*AdminCommand) QueryUsers 

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

QueryUsers returns user information for all users.

type AdminPolicy 

type AdminPolicy struct {

	// User administration command socket timeout.
	// Default is 2 seconds.
	Timeout time.Duration
}

AdminPolicy contains attributes used for user administration commands.

func NewAdminPolicy 

func NewAdminPolicy() *AdminPolicy

NewAdminPolicy generates a new AdminPolicy with default values.

type AerospikeBlob 

type AerospikeBlob interface {
	// EncodeBlob returns a byte slice representing the encoding of the
	// receiver for transmission to a Decoder, usually of the same
	// concrete type.
	EncodeBlob() ([]byte, error)
}

AerospikeBlob interface allows the user to write a conversion function from their value to []bytes.

type AerospikeError 

type AerospikeError struct {

	// Node where the error occurred
	Node *Node

	// ResultCode determines the type of error
	ResultCode types.ResultCode

	// InDoubt determines if the command was sent to the server, but
	// there is doubt if the server received and executed the command
	// and changed the data. Only applies to commands that change data
	InDoubt bool

	// Iteration determies on which retry the error occurred
	Iteration int
	// contains filtered or unexported fields
}

AerospikeError implements Error interface for aerospike specific errors. All errors returning from the library are of this type. Errors resulting from Go's stdlib are not translated to this type, unless they are a net.Timeout error. Refer to errors_test.go for examples. To be able to check for error type, you could use the idiomatic errors.Is and errors.As patterns: 

if errors.Is(err, as.ErrTimeout) {
    ...
}

or 

if errors.Is(err, &as.AerospikeError{ResultCode: ast.PARAMETER_ERROR}) {
    ...
}

or 

if err.Matches(ast.TIMEOUT, ast.NETWORK_ERROR, ast.PARAMETER_ERROR) {
    ...
}

or 

ae := &as.AerospikeError{}
if errors.As(err, &ae) {
    println(ae.ResultCode)
}

func (*AerospikeError) As 

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

As implements the interface for errors.As function.

func (*AerospikeError) Error 

func (ase *AerospikeError) Error() string

Error implements the error interface

func (*AerospikeError) Is 

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

Is compares an error with the AerospikeError. If the error is not of type *AerospikeError, it will return false. Otherwise, it will compare ResultCode and Node (if it exists), and will return a result accordingly. If passed error's InDoubt is set to true, the InDoubt property will also be checked. You should not check if the error's InDoubt is false, since it is not checked when the passed error's InDoubt is false.

func (*AerospikeError) Matches 

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

Matches returns true if the error or any of its wrapped errors contains any of the passed results codes. For convenience, it will return false if the error is nil.

func (*AerospikeError) Trace 

func (ase *AerospikeError) Trace() string

Trace returns a stack trace of where the error originates from

func (*AerospikeError) Unwrap 

func (ase *AerospikeError) Unwrap() error

Unwrap will return the error wrapped inside the error, or nil.

type AuthMode 

type AuthMode int

AuthMode determines authentication mode. 

const (
	// AuthModeInternal uses internal authentication only when user/password defined. Hashed password is stored
	// on the server. Do not send clear password. This is the default.
	AuthModeInternal AuthMode = iota

	// AuthModeExternal uses external authentication (like LDAP) when user/password defined. Specific external authentication is
	// configured on server.  If TLSConfig is defined, sends clear password on node login via TLS.
	// Will return an error if TLSConfig is not defined.
	AuthModeExternal

	// AuthModePKI allows authentication and authorization based on a certificate. No user name or
	// password needs to be configured. Requires TLS and a client certificate.
	// Requires server version 5.7.0+
	AuthModePKI
)

type BasePolicy 

type BasePolicy struct {
	// FilterExpression is the optional Filter Expression. Supported on Server v5.2+
	FilterExpression *Expression

	// ReadModeAP indicates read policy for AP (availability) namespaces.
	ReadModeAP ReadModeAP //= ONE

	// ReadModeSC indicates read policy for SC (strong consistency) namespaces.
	ReadModeSC ReadModeSC //= SESSION;

	// TotalTimeout specifies total transaction timeout.
	//
	// The TotalTimeout is tracked on the client and also sent to the server along
	// with the transaction in the wire protocol. The client will most likely
	// timeout first, but the server has the capability to Timeout the transaction.
	//
	// If TotalTimeout is not zero and TotalTimeout is reached before the transaction
	// completes, the transaction will abort with TotalTimeout error.
	//
	// If TotalTimeout is zero, there will be no time limit and the transaction will retry
	// on network timeouts/errors until MaxRetries is exceeded. If MaxRetries is exceeded, the
	// transaction also aborts with Timeout error.
	//
	// Default: 0 (no time limit and rely on MaxRetries).
	TotalTimeout time.Duration

	// SocketTimeout determines network timeout for each attempt.
	//
	// If SocketTimeout is not zero and SocketTimeout is reached before an attempt completes,
	// the Timeout above is checked. If Timeout is not exceeded, the transaction
	// is retried. If both SocketTimeout and Timeout are non-zero, SocketTimeout must be less
	// than or equal to Timeout, otherwise Timeout will also be used for SocketTimeout.
	//
	// Default: 30s
	SocketTimeout time.Duration

	// MaxRetries determines the maximum number of retries before aborting the current transaction.
	// The initial attempt is not counted as a retry.
	//
	// If MaxRetries is exceeded, the transaction will abort with an error.
	//
	// WARNING: Database writes that are not idempotent (such as AddOp)
	// should not be retried because the write operation may be performed
	// multiple times if the client timed out previous transaction attempts.
	// It's important to use a distinct WritePolicy for non-idempotent
	// writes which sets maxRetries = 0;
	//
	// Default for read: 2 (initial attempt + 2 retries = 3 attempts)
	//
	// Default for write: 0 (no retries)
	//
	// Default for partition scan or query with nil filter: 5
	// (6 attempts. See ScanPolicy comments.)
	//
	// No default for legacy scan/query. No retries are allowed for these commands.
	MaxRetries int //= 2;

	// SleepBetweenRtries determines the duration to sleep between retries.  Enter zero to skip sleep.
	// This field is ignored when maxRetries is zero.
	// This field is also ignored in async mode.
	//
	// The sleep only occurs on connection errors and server timeouts
	// which suggest a node is down and the cluster is reforming.
	// The sleep does not occur when the client's socketTimeout expires.
	//
	// Reads do not have to sleep when a node goes down because the cluster
	// does not shut out reads during cluster reformation.  The default for
	// reads is zero.
	//
	// The default for writes is also zero because writes are not retried by default.
	// Writes need to wait for the cluster to reform when a node goes down.
	// Immediate write retries on node failure have been shown to consistently
	// result in errors.  If maxRetries is greater than zero on a write, then
	// sleepBetweenRetries should be set high enough to allow the cluster to
	// reform (>= 500ms).
	SleepBetweenRetries time.Duration //= 1ms;

	// SleepMultiplier specifies the multiplying factor to be used for exponential backoff during retries.
	// Default to (1.0); Only values greater than 1 are valid.
	SleepMultiplier float64 //= 1.0;

	// ExitFastOnExhaustedConnectionPool determines if a command that tries to get a
	// connection from the connection pool will wait and retry in case the pool is
	// exhausted until a connection becomes available (or the TotalTimeout is reached).
	// If set to true, an error will be return immediately.
	// If set to false, getting a connection will be retried.
	// This only applies if LimitConnectionsToQueueSize is set to true and the number of open connections to a node has reached ConnectionQueueSize.
	// The default is false
	ExitFastOnExhaustedConnectionPool bool // false

	// SendKey determines to whether send user defined key in addition to hash digest on both reads and writes.
	// If the key is sent on a write, the key will be stored with the record on
	// the server.
	// The default is to not send the user defined key.
	SendKey bool // = false

	// UseCompression uses zlib compression on command buffers sent to the server and responses received
	// from the server when the buffer size is greater than 128 bytes.
	//
	// This option will increase cpu and memory usage (for extra compressed buffers),but
	// decrease the size of data sent over the network.
	//
	// Default: false
	UseCompression bool // = false

	// ReplicaPolicy determines the node to send the read commands containing the key's partition replica type.
	// Write commands are not affected by this setting, because all writes are directed
	// to the node containing the key's master partition.
	// Scan and query are also not affected by replica algorithms.
	// Default to sending read commands to the node containing the key's master partition.
	ReplicaPolicy ReplicaPolicy
}

BasePolicy encapsulates parameters for transaction policy attributes used in all database operation calls.

func NewPolicy 

func NewPolicy() *BasePolicy

NewPolicy generates a new BasePolicy instance with default values.

func (*BasePolicy) GetBasePolicy 

func (p *BasePolicy) GetBasePolicy() *BasePolicy

GetBasePolicy returns embedded BasePolicy in all types that embed this struct.

type BatchDelete 

type BatchDelete struct {
	BatchRecord
	// contains filtered or unexported fields
}

BatchDelete encapsulates a batch delete operation.

func NewBatchDelete 

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

NewBatchDelete creates a batch delete operation.

type BatchDeletePolicy 

type BatchDeletePolicy struct {
	// FilterExpression is optional expression filter. If FilterExpression exists and evaluates to false, the specific batch key
	// request is not performed and BatchRecord.ResultCode is set to type.FILTERED_OUT.
	// Default: nil
	FilterExpression *Expression

	// Desired consistency guarantee when committing a transaction on the server. The default
	// (COMMIT_ALL) indicates that the server should wait for master and all replica commits to
	// be successful before returning success to the client.
	// Default: CommitLevel.COMMIT_ALL
	CommitLevel CommitLevel //= COMMIT_ALL

	// Qualify how to handle record deletes based on record generation. The default (NONE)
	// indicates that the generation is not used to restrict deletes.
	// Default: GenerationPolicy.NONE
	GenerationPolicy GenerationPolicy //= GenerationPolicy.NONE;

	// Expected generation. Generation is the number of times a record has been modified
	// (including creation) on the server. This field is only relevant when generationPolicy
	// is not NONE.
	// Default: 0
	Generation uint32

	// If the transaction results in a record deletion, leave a tombstone for the record.
	// This prevents deleted records from reappearing after node failures.
	// Valid for Aerospike Server Enterprise Edition only.
	// Default: false (do not tombstone deleted records).
	DurableDelete bool

	// Send user defined key in addition to hash digest.
	// If true, the key will be stored with the tombstone record on the server.
	// Default: false (do not send the user defined key)
	SendKey bool
}

BatchDeletePolicy is used in batch delete commands.

func NewBatchDeletePolicy 

func NewBatchDeletePolicy() *BatchDeletePolicy

NewBatchDeletePolicy returns a default BatchDeletePolicy.

type BatchPolicy 

type BatchPolicy struct {
	BasePolicy

	// Maximum number of concurrent batch request goroutines to server nodes at any point in time.
	// If there are 16 node/namespace combinations requested and ConcurrentNodes is 8,
	// then batch requests will be made for 8 node/namespace combinations in concurrent goroutines.
	// When a request completes, a new request will be issued until all 16 goroutines are complete.
	//
	// Values:
	// 1: Issue batch requests sequentially.  This mode has a performance advantage for small
	// to medium sized batch sizes because requests can be issued in the main transaction goroutine.
	// This is the default.
	// 0: Issue all batch requests in concurrent goroutines.  This mode has a performance
	// advantage for extremely large batch sizes because each node can process the request
	// immediately.  The downside is extra goroutines will need to be created (or taken from
	// a goroutine pool).
	// > 0: Issue up to ConcurrentNodes batch requests in concurrent goroutines.  When a request
	// completes, a new request will be issued until all goroutines are complete.  This mode
	// prevents too many concurrent goroutines being created for large cluster implementations.
	// The downside is extra goroutines will still need to be created (or taken from a goroutine pool).
	ConcurrentNodes int // = 1

	// Allow batch to be processed immediately in the server's receiving thread when the server
	// deems it to be appropriate.  If false, the batch will always be processed in separate
	// transaction goroutines.  This field is only relevant for the new batch index protocol.
	//
	// For batch exists or batch reads of smaller sized records (<= 1K per record), inline
	// processing will be significantly faster on "in memory" namespaces.  The server disables
	// inline processing on disk based namespaces regardless of this policy field.
	//
	// Inline processing can introduce the possibility of unfairness because the server
	// can process the entire batch before moving onto the next command.
	AllowInline bool //= true

	// Allow batch to be processed immediately in the server's receiving thread for SSD
	// namespaces. If false, the batch will always be processed in separate service threads.
	// Server versions before 6.0 ignore this field.
	//
	// Inline processing can introduce the possibility of unfairness because the server
	// can process the entire batch before moving onto the next command.
	//
	// Default: false
	AllowInlineSSD bool // = false

	// Should all batch keys be attempted regardless of errors. This field is used on both
	// the client and server. The client handles node specific errors and the server handles
	// key specific errors.
	//
	// If true, every batch key is attempted regardless of previous key specific errors.
	// Node specific errors such as timeouts stop keys to that node, but keys directed at
	// other nodes will continue to be processed.
	//
	// If false, the server will stop the batch to its node on most key specific errors.
	// The exceptions are types.KEY_NOT_FOUND_ERROR and types.FILTERED_OUT which never stop the batch.
	// The client will stop the entire batch on node specific errors for sync commands
	// that are run in sequence (MaxConcurrentThreads == 1). The client will not stop
	// the entire batch for async commands or sync commands run in parallel.
	//
	// Server versions &lt; 6.0 do not support this field and treat this value as false
	// for key specific errors.
	//
	// Default: true
	RespondAllKeys bool //= true;

	// AllowPartialResults determines if the results for some nodes should be returned in case
	// some nodes encounter an error. The result for the unreceived records will be nil.
	// The returned records will be safe to use, since only fully received data will be parsed
	// and set.
	//
	// This flag is only supported for BatchGet and BatchGetHeader methods. BatchGetComplex always returns
	// partial results by design.
	AllowPartialResults bool //= false
}

BatchPolicy encapsulates parameters for policy attributes used in write operations. This object is passed into methods where database writes can occur.

func NewBatchPolicy 

func NewBatchPolicy() *BatchPolicy

NewBatchPolicy initializes a new BatchPolicy instance with default parameters.

func NewReadBatchPolicy 

func NewReadBatchPolicy() *BatchPolicy

NewReadBatchPolicy initializes a new BatchPolicy instance for reads.

func NewWriteBatchPolicy 

func NewWriteBatchPolicy() *BatchPolicy

NewWriteBatchPolicy initializes a new BatchPolicy instance for writes.

type BatchRead 

type BatchRead struct {
	BatchRecord

	// BinNames specifies the Bins to retrieve for this key.
	// BinNames are mutually exclusive with Ops.
	BinNames []string

	// ReadAllBins defines what data should be read from the record.
	// If true, ignore binNames and read all bins.
	// If false and binNames are set, read specified binNames.
	// If false and binNames are not set, read record header (generation, expiration) only.
	ReadAllBins bool //= false

	// Ops specifies the operations to perform for every key.
	// Ops are mutually exclusive with BinNames.
	// A binName can be emulated with `GetOp(binName)`
	// Supported by server v5.6.0+.
	Ops []*Operation
	// contains filtered or unexported fields
}

BatchRead specifies the Key and bin names used in batch read commands where variable bins are needed for each key.

func NewBatchRead 

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

NewBatchRead defines a key and bins to retrieve in a batch operation.

func NewBatchReadHeader 

func NewBatchReadHeader(key *Key) *BatchRead

NewBatchReadHeader defines a key to retrieve the record headers only in a batch operation.

func NewBatchReadOps 

func NewBatchReadOps(key *Key, binNames []string, ops []*Operation) *BatchRead

NewBatchReadOps defines a key and bins to retrieve in a batch operation, including expressions.

func (*BatchRead) String 

func (br *BatchRead) String() string

String implements the Stringer interface.

type BatchReadPolicy 

type BatchReadPolicy struct {
	// FilterExpression is the optional expression filter. If FilterExpression exists and evaluates to false, the specific batch key
	// request is not performed and BatchRecord.ResultCode is set to types.FILTERED_OUT.
	//
	// Default: nil
	FilterExpression *Expression

	// ReadModeAP indicates read policy for AP (availability) namespaces.
	ReadModeAP ReadModeAP //= ONE

	// ReadModeSC indicates read policy for SC (strong consistency) namespaces.
	ReadModeSC ReadModeSC //= SESSION;
}

Policy attributes used in batch read commands.

func NewBatchReadPolicy 

func NewBatchReadPolicy() *BatchReadPolicy

NewBatchReadPolicy returns a policy instance for BatchRead commands.

type BatchRecord 

type BatchRecord struct {
	// Key.
	Key *Key

	// Record result after batch command has completed.  Will be nil if record was not found
	// or an error occurred. See ResultCode.
	Record *Record

	// ResultCode for this returned record. See types.ResultCode.
	// If not OK, the record will be nil.
	ResultCode types.ResultCode

	// Err encapsulates the possible error chain for this keys
	Err Error

	// InDoubt signifies the possiblity that the write transaction may have completed even though an error
	// occurred for this record. This may be the case when a client error occurs (like timeout)
	// after the command was sent to the server.
	InDoubt bool
	// contains filtered or unexported fields
}

BatchRecord encasulates the Batch key and record result.

func (*BatchRecord) BatchRec 

func (br *BatchRecord) BatchRec() *BatchRecord

BatchRec returns the embedded batch record in the interface.

func (*BatchRecord) String 

func (br *BatchRecord) String() string

String implements the Stringer interface.

type BatchRecordIfc 

type BatchRecordIfc interface {
	// Returns the BatchRecord
	BatchRec() *BatchRecord

	String() string
	// contains filtered or unexported methods
}

BatchRecordIfc is the interface type to encapsulate BatchRead, BatchWrite and BatchUDF commands.

type BatchUDF 

type BatchUDF struct {
	BatchRecord
	// contains filtered or unexported fields
}

BatchUDF encapsulates a batch user defined function operation.

func NewBatchUDF 

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

NewBatchUDF creates a batch UDF operation.

type BatchUDFPolicy 

type BatchUDFPolicy struct {
	// Optional expression filter. If FilterExpression exists and evaluates to false, the specific batch key
	// request is not performed and BatchRecord.ResultCode is set to types.FILTERED_OUT.
	//
	// Default: nil
	FilterExpression *Expression

	// Desired consistency guarantee when committing a transaction on the server. The default
	// (COMMIT_ALL) indicates that the server should wait for master and all replica commits to
	// be successful before returning success to the client.
	//
	// Default: CommitLevel.COMMIT_ALL
	CommitLevel CommitLevel //= COMMIT_ALL

	// Expiration determines record expiration in seconds. Also known as TTL (Time-To-Live).
	// Seconds record will live before being removed by the server.
	// Expiration values:
	// TTLServerDefault (0): Default to namespace configuration variable "default-ttl" on the server.
	// TTLDontExpire (MaxUint32): Never expire for Aerospike 2 server versions >= 2.7.2 and Aerospike 3+ server
	// TTLDontUpdate (MaxUint32 - 1): Do not change ttl when record is written. Supported by Aerospike server versions >= 3.10.1
	// > 0: Actual expiration in seconds.
	Expiration uint32

	// DurableDelete leaves a tombstone for the record if the transaction results in a record deletion.
	// This prevents deleted records from reappearing after node failures.
	// Valid for Aerospike Server Enterprise Edition 3.10+ only.
	DurableDelete bool

	// SendKey determines to whether send user defined key in addition to hash digest on both reads and writes.
	// If the key is sent on a write, the key will be stored with the record on
	// the server.
	// The default is to not send the user defined key.
	SendKey bool // = false
}

Policy attributes used in batch UDF execute commands.

func NewBatchUDFPolicy 

func NewBatchUDFPolicy() *BatchUDFPolicy

Copy constructor.

type BatchWrite 

type BatchWrite struct {
	BatchRecord
	// contains filtered or unexported fields
}

BatchWrite encapsulates a batch key and read/write operations with write policy.

func NewBatchWrite 

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

NewBatchWrite initializesa policy, batch key and read/write operations. ANy GetOp() is not allowed because it returns a variable number of bins and makes it difficult (sometimes impossible) to lineup operations with results. Instead, use GetBinOp(string) for each bin name.

type BatchWritePolicy 

type BatchWritePolicy struct {
	// FilterExpression is optional expression filter. If FilterExpression exists and evaluates to false, the specific batch key
	// request is not performed and BatchRecord#resultCode is set to types.FILTERED_OUT.
	//
	// Default: nil
	FilterExpression *Expression

	// RecordExistsAction qualifies how to handle writes where the record already exists.
	RecordExistsAction RecordExistsAction //= RecordExistsAction.UPDATE;

	// Desired consistency guarantee when committing a transaction on the server. The default
	// (COMMIT_ALL) indicates that the server should wait for master and all replica commits to
	// be successful before returning success to the client.
	//
	// Default: CommitLevel.COMMIT_ALL
	CommitLevel CommitLevel //= COMMIT_ALL

	// GenerationPolicy qualifies how to handle record writes based on record generation. The default (NONE)
	// indicates that the generation is not used to restrict writes.
	//
	// The server does not support this field for UDF execute() calls. The read-modify-write
	// usage model can still be enforced inside the UDF code itself.
	//
	// Default: GenerationPolicy.NONE
	// indicates that the generation is not used to restrict writes.
	GenerationPolicy GenerationPolicy //= GenerationPolicy.NONE;

	// Expected generation. Generation is the number of times a record has been modified
	// (including creation) on the server. If a write operation is creating a record,
	// the expected generation would be 0. This field is only relevant when
	// generationPolicy is not NONE.
	//
	// The server does not support this field for UDF execute() calls. The read-modify-write
	// usage model can still be enforced inside the UDF code itself.
	//
	// Default: 0
	Generation uint32

	// Expiration determines record expiration in seconds. Also known as TTL (Time-To-Live).
	// Seconds record will live before being removed by the server.
	// Expiration values:
	// TTLServerDefault (0): Default to namespace configuration variable "default-ttl" on the server.
	// TTLDontExpire (MaxUint32): Never expire for Aerospike 2 server versions >= 2.7.2 and Aerospike 3+ server
	// TTLDontUpdate (MaxUint32 - 1): Do not change ttl when record is written. Supported by Aerospike server versions >= 3.10.1
	// > 0: Actual expiration in seconds.
	Expiration uint32

	// DurableDelete leaves a tombstone for the record if the transaction results in a record deletion.
	// This prevents deleted records from reappearing after node failures.
	// Valid for Aerospike Server Enterprise Edition 3.10+ only.
	DurableDelete bool

	// SendKey determines to whether send user defined key in addition to hash digest on both reads and writes.
	// If the key is sent on a write, the key will be stored with the record on
	// the server.
	// The default is to not send the user defined key.
	SendKey bool // = false
}

Policy attributes used in batch write commands.

func NewBatchWritePolicy 

func NewBatchWritePolicy() *BatchWritePolicy

type Bin 

type Bin struct {
	// Bin name. Current limit is 14 characters.
	Name string

	// Bin value.
	Value Value
}

Bin encapsulates a field name/value pair.

func NewBin 

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

NewBin generates a new Bin instance, specifying bin name and string value. For servers configured as "single-bin", enter an empty name.

func (*Bin) String 

func (bn *Bin) String() string

String implements Stringer interface.

type BinMap 

type BinMap map[string]interface{}

BinMap is used to define a map of bin names to values.

type BitOverflowAction 

type BitOverflowAction int

BitOverflowAction specifies the action to take when bitwise add/subtract results in overflow/underflow. 

const (
	// BitOverflowActionFail specifies to fail operation with error.
	BitOverflowActionFail BitOverflowAction = 0

	// BitOverflowActionSaturate specifies that in add/subtract overflows/underflows, set to max/min value.
	// Example: MAXINT + 1 = MAXINT
	BitOverflowActionSaturate BitOverflowAction = 2

	// BitOverflowActionWrap specifies that in add/subtract overflows/underflows, wrap the value.
	// Example: MAXINT + 1 = -1
	BitOverflowActionWrap BitOverflowAction = 4
)

type BitPolicy 

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

BitPolicy determines the Bit operation policy.

func DefaultBitPolicy 

func DefaultBitPolicy() *BitPolicy

DefaultBitPolicy will return the default BitPolicy

func NewBitPolicy 

func NewBitPolicy(flags int) *BitPolicy

NewBitPolicy will return a BitPolicy will provided flags.

type BitResizeFlags 

type BitResizeFlags int

BitResizeFlags specifies the bitwise operation flags for resize. 

const (
	// BitResizeFlagsDefault specifies the defalt flag.
	BitResizeFlagsDefault BitResizeFlags = 0

	// BitResizeFlagsFromFront Adds/removes bytes from the beginning instead of the end.
	BitResizeFlagsFromFront BitResizeFlags = 1

	// BitResizeFlagsGrowOnly will only allow the []byte size to increase.
	BitResizeFlagsGrowOnly BitResizeFlags = 2

	// BitResizeFlagsShrinkOnly will only allow the []byte size to decrease.
	BitResizeFlagsShrinkOnly BitResizeFlags = 4
)

type BoolValue 

type BoolValue bool

BoolValue encapsulates a boolean value. Supported by Aerospike server v5.6+ only.

func (BoolValue) EstimateSize 

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

EstimateSize returns the size of the BoolValue in wire protocol.

func (BoolValue) GetObject 

func (vb BoolValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (BoolValue) GetType 

func (vb BoolValue) GetType() int

GetType returns wire protocol value type.

func (BoolValue) String 

func (vb BoolValue) String() string

String implements Stringer interface.

type BufferEx 

type BufferEx interface {
	WriteInt64(num int64) int
	WriteUint64(num uint64) int
	WriteInt32(num int32) int
	WriteUint32(num uint32) int
	WriteInt16(num int16) int
	WriteUint16(num uint16) int
	WriteFloat32(float float32) int
	WriteFloat64(float float64) int
	WriteBool(b bool) int
	WriteByte(b byte)
	WriteString(s string) (int, Error)
	Write(b []byte) (int, Error)
}

BufferEx is a specialized buffer interface for aerospike client.

type BytesValue 

type BytesValue []byte

BytesValue encapsulates an array of bytes.

func NewBlobValue 

func NewBlobValue(object AerospikeBlob) BytesValue

NewBlobValue accepts an AerospikeBlob interface, and automatically converts it to a BytesValue. If Encode returns an err, it will panic.

func NewBytesValue 

func NewBytesValue(bytes []byte) BytesValue

NewBytesValue generates a ByteValue instance.

func (BytesValue) EstimateSize 

func (vl BytesValue) EstimateSize() (int, Error)

EstimateSize returns the size of the BytesValue in wire protocol.

func (BytesValue) GetObject 

func (vl BytesValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (BytesValue) GetType 

func (vl BytesValue) GetType() int

GetType returns wire protocol value type.

func (BytesValue) String 

func (vl BytesValue) String() string

String implements Stringer interface.

type CDTContext 

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

CDTContext defines Nested CDT context. Identifies the location of nested list/map to apply the operation. for the current level. An array of CTX identifies location of the list/map on multiple levels on nesting.

func CtxListIndex 

func CtxListIndex(index int) *CDTContext

CtxListIndex defines Lookup list by index offset. If the index is negative, the resolved index starts backwards from end of list. If an index is out of bounds, a parameter error will be returned. Examples: 0: First item. 4: Fifth item. -1: Last item. -3: Third to last item.

func CtxListIndexCreate 

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

CtxListIndexCreate list with given type at index offset, given an order and pad.

func CtxListRank 

func CtxListRank(rank int) *CDTContext

CtxListRank defines Lookup list by rank. 0 = smallest value N = Nth smallest value -1 = largest value

func CtxListValue 

func CtxListValue(key Value) *CDTContext

CtxListValue defines Lookup list by value.

func CtxMapIndex 

func CtxMapIndex(index int) *CDTContext

CtxMapIndex defines Lookup map by index offset. If the index is negative, the resolved index starts backwards from end of list. If an index is out of bounds, a parameter error will be returned. Examples: 0: First item. 4: Fifth item. -1: Last item. -3: Third to last item.

func CtxMapKey 

func CtxMapKey(key Value) *CDTContext

CtxMapKey defines Lookup map by key.

func CtxMapKeyCreate 

func CtxMapKeyCreate(key Value, order mapOrderType) *CDTContext

CtxMapKeyCreate creates map with given type at map key.

func CtxMapRank 

func CtxMapRank(rank int) *CDTContext

CtxMapRank defines Lookup map by rank. 0 = smallest value N = Nth smallest value -1 = largest value

func CtxMapValue 

func CtxMapValue(key Value) *CDTContext

CtxMapValue defines Lookup map by value.

type Client 

type Client struct {

	// DefaultPolicy is used for all read commands without a specific policy.
	DefaultPolicy *BasePolicy
	// DefaultBatchPolicy is the default parent policy used in batch read commands. Base policy fields
	// include socketTimeout, totalTimeout, maxRetries, etc...
	DefaultBatchPolicy *BatchPolicy
	// DefaultBatchWritePolicy is the default write policy used in batch operate commands.
	// Write policy fields include generation, expiration, durableDelete, etc...
	DefaultBatchWritePolicy *BatchWritePolicy
	// DefaultBatchDeletePolicy is the default delete policy used in batch delete commands.
	DefaultBatchDeletePolicy *BatchDeletePolicy
	// DefaultBatchUDFPolicy is the default user defined function policy used in batch UDF excecute commands.
	DefaultBatchUDFPolicy *BatchUDFPolicy
	// DefaultWritePolicy is used for all write commands without a specific policy.
	DefaultWritePolicy *WritePolicy
	// DefaultScanPolicy is used for all scan commands without a specific policy.
	DefaultScanPolicy *ScanPolicy
	// DefaultQueryPolicy is used for all query commands without a specific policy.
	DefaultQueryPolicy *QueryPolicy
	// DefaultAdminPolicy is used for all security commands without a specific policy.
	DefaultAdminPolicy *AdminPolicy
	// DefaultInfoPolicy is used for all info commands without a specific policy.
	DefaultInfoPolicy *InfoPolicy
	// contains filtered or unexported fields
}

Client encapsulates an Aerospike cluster. All database operations are available against this object.

func (*Client) Add 

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

Add adds integer bin values to existing record bin values. The policy specifies the transaction timeout, record expiration and how the transaction is handled when the record already exists. This call only works for integer values. If the policy is nil, the default relevant policy will be used.

Example 
key, err := as.NewKey("test", "test", "addkey")
if err != nil {
	log.Fatal(err)
}

if _, err = client.Delete(nil, key); err != nil {
	log.Fatal(err)
}

// Add to a non-existing record/bin, should create a record
bin := as.NewBin("bin", 10)
if err = client.AddBins(nil, key, bin); err != nil {
	log.Fatal(err)
}

// Add to 5 to the original 10
bin = as.NewBin("bin", 5)
if err = client.AddBins(nil, key, bin); err != nil {
	log.Fatal(err)
}

// Check the result
record, err := client.Get(nil, key, bin.Name)
if err != nil {
	log.Fatal(err)
}
fmt.Println(record.Bins["bin"])

// Demonstrate add and get combined.
bin = as.NewBin("bin", 30)
if record, err = client.Operate(nil, key, as.AddOp(bin), as.GetOp()); err != nil {
	log.Fatal(err)
}

fmt.Println(record.Bins["bin"])

Output:

15
45

func (*Client) AddBins 

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

AddBins works the same as Add, but avoids BinMap allocation and iteration.

func (*Client) Append 

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

Append appends bin value's string to existing record bin values. The policy specifies the transaction timeout, record expiration and how the transaction is handled when the record already exists. This call only works for string and []byte values. If the policy is nil, the default relevant policy will be used.

Example 
key, err := as.NewKey("test", "test", "appendkey")
if err != nil {
	log.Fatal(err)
}

if _, err = client.Delete(nil, key); err != nil {
	log.Fatal(err)
}

// Create by appending to non-existing value
bin1 := as.NewBin("myBin", "Hello")
if err = client.AppendBins(nil, key, bin1); err != nil {
	log.Fatal(err)
}

// Append World
bin2 := as.NewBin("myBin", " World")
if err = client.AppendBins(nil, key, bin2); err != nil {
	log.Fatal(err)
}

record, err := client.Get(nil, key)
if err != nil {
	log.Fatal(err)
}

fmt.Println(record.Bins["myBin"])

Output:

Hello World

func (*Client) AppendBins 

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

AppendBins works the same as Append, but avoids BinMap allocation and iteration.

func (*Client) BatchDelete 

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

BatchDelete deletes records for specified keys. If a key is not found, the corresponding result BatchRecord.ResultCode will be types.KEY_NOT_FOUND_ERROR.

Requires server version 6.0+

func (*Client) BatchExecute 

func (clnt *Client) BatchExecute(policy *BatchPolicy, udfPolicy *BatchUDFPolicy, keys []*Key, packageName string, functionName string, args ...Value) ([]*BatchRecord, Error)

BatchExecute will read/write multiple records for specified batch keys in one batch call. This method allows different namespaces/bins for each key in the batch. The returned records are located in the same list.

BatchRecord can be *BatchRead, *BatchWrite, *BatchDelete or *BatchUDF.

Requires server version 6.0+

func (*Client) BatchExists 

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

BatchExists determines if multiple record keys exist in one batch request. The returned boolean array is in positional order with the original key array order. The policy can be used to specify timeouts. If the policy is nil, the default relevant policy will be used.

func (*Client) BatchGet 

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

BatchGet reads multiple record headers and bins for specified keys in one batch request. The returned records are in positional order with the original key array order. If a key is not found, the positional record will be nil. The policy can be used to specify timeouts. If the policy is nil, the default relevant policy will be used.

func (*Client) BatchGetComplex 

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

BatchGetComplex reads multiple records for specified batch keys in one batch call. This method allows different namespaces/bins to be requested for each key in the batch. The returned records are located in the same list. If the BatchRead key field is not found, the corresponding record field will be nil. The policy can be used to specify timeouts and maximum concurrent threads. This method requires Aerospike Server version >= 3.6.0.

func (*Client) BatchGetHeader 

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

BatchGetHeader reads multiple record header data for specified keys in one batch request. The returned records are in positional order with the original key array order. If a key is not found, the positional record will be nil. The policy can be used to specify timeouts. If the policy is nil, the default relevant policy will be used.

func (*Client) BatchGetObjects 

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

BatchGetObjects reads multiple record headers and bins for specified keys in one batch request. The returned objects are in positional order with the original key array order. If a key is not found, the positional object will not change, and the positional found boolean will be false. The policy can be used to specify timeouts. If the policy is nil, the default relevant policy will be used.

func (*Client) BatchGetOperate 

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

BatchGetOperate reads multiple records for specified keys using read operations in one batch call. The returned records are in positional order with the original key array order. If a key is not found, the positional record will be nil.

If a batch request to a node fails, the entire batch is cancelled.

func (*Client) BatchOperate 

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

BatchOperate will read/write multiple records for specified batch keys in one batch call. This method allows different namespaces/bins for each key in the batch. The returned records are located in the same list.

BatchRecord can be *BatchRead, *BatchWrite, *BatchDelete or *BatchUDF.

Requires server version 6.0+

func (*Client) ChangePassword 

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

ChangePassword changes a user's password. Clear-text password will be hashed using bcrypt before sending to server.

func (*Client) Close 

func (clnt *Client) Close()

Close closes all client connections to database server nodes.

func (*Client) Cluster 

func (clnt *Client) Cluster() *Cluster

Cluster exposes the cluster object to the user

func (*Client) CreateComplexIndex 

func (clnt *Client) CreateComplexIndex(
	policy *WritePolicy,
	namespace string,
	setName string,
	indexName string,
	binName string,
	indexType IndexType,
	indexCollectionType IndexCollectionType,
) (*IndexTask, Error)

CreateComplexIndex creates a secondary index, with the ability to put indexes on bin containing complex data types, e.g: Maps and Lists. This asynchronous server call will return before the command is complete. The user can optionally wait for command completion by using the returned IndexTask instance. This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) CreateIndex 

func (clnt *Client) CreateIndex(
	policy *WritePolicy,
	namespace string,
	setName string,
	indexName string,
	binName string,
	indexType IndexType,
) (*IndexTask, Error)

CreateIndex creates a secondary index. This asynchronous server call will return before the command is complete. The user can optionally wait for command completion by using the returned IndexTask instance. This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) CreateRole 

func (clnt *Client) CreateRole(policy *AdminPolicy, roleName string, privileges []Privilege, whitelist []string, readQuota, writeQuota uint32) Error

CreateRole creates a user-defined role. Quotas require server security configuration "enable-quotas" to be set to true. Pass 0 for quota values for no limit.

func (*Client) CreateUser 

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

CreateUser creates a new user with password and roles. Clear-text password will be hashed using bcrypt before sending to server.

func (*Client) Delete 

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

Delete deletes a record for specified key. The policy specifies the transaction timeout. If the policy is nil, the default relevant policy will be used.

func (*Client) DropIndex 

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

DropIndex deletes a secondary index. It will block until index is dropped on all nodes. This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) DropRole 

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

DropRole removes a user-defined role.

func (*Client) DropUser 

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

DropUser removes a user from the cluster.

func (*Client) Execute 

func (clnt *Client) Execute(policy *WritePolicy, key *Key, packageName string, functionName string, args ...Value) (interface{}, Error)

Execute executes a user defined function on server and return results. The function operates on a single record. The package name is used to locate the udf file location:

udf file = <server udf dir>/<package name>.lua

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) ExecuteUDF 

func (clnt *Client) ExecuteUDF(policy *QueryPolicy,
	statement *Statement,
	packageName string,
	functionName string,
	functionArgs ...Value,
) (*ExecuteTask, Error)

ExecuteUDF applies user defined function on records that match the statement filter. Records are not returned to the client. This asynchronous server call will return before command is complete. The user can optionally wait for command completion by using the returned ExecuteTask instance.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) ExecuteUDFNode 

func (clnt *Client) ExecuteUDFNode(policy *QueryPolicy,
	node *Node,
	statement *Statement,
	packageName string,
	functionName string,
	functionArgs ...Value,
) (*ExecuteTask, Error)

ExecuteUDFNode applies user defined function on records that match the statement filter on the specified node. Records are not returned to the client. This asynchronous server call will return before command is complete. The user can optionally wait for command completion by using the returned ExecuteTask instance.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) Exists 

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

Exists determine if a record key exists. The policy can be used to specify timeouts. If the policy is nil, the default relevant policy will be used.

func (*Client) Get 

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

Get reads a record header and bins for specified key. The policy can be used to specify timeouts. If the policy is nil, the default relevant policy will be used.

func (*Client) GetHeader 

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

GetHeader reads a record generation and expiration only for specified key. Bins are not read. The policy can be used to specify timeouts. If the policy is nil, the default relevant policy will be used.

func (*Client) GetNodeNames 

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

GetNodeNames returns a list of active server node names in the cluster.

func (*Client) GetNodes 

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

GetNodes returns an array of active server nodes in the cluster.

func (*Client) GetObject 

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

GetObject reads a record for specified key and puts the result into the provided object. The policy can be used to specify timeouts. If the policy is nil, the default relevant policy will be used.

func (*Client) GrantPrivileges 

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

GrantPrivileges grant privileges to a user-defined role.

func (*Client) GrantRoles 

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

GrantRoles adds roles to user's list of roles.

func (*Client) IsConnected 

func (clnt *Client) IsConnected() bool

IsConnected determines if the client is ready to talk to the database server cluster.

func (*Client) ListUDF 

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

ListUDF lists all packages containing user defined functions in the server. This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) Operate 

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

Operate performs multiple read/write operations on a single key in one batch request. An example would be to add an integer value to an existing record and then read the result, all in one database call.

If the policy is nil, the default relevant policy will be used.

func (*Client) Prepend 

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

Prepend prepends bin value's string to existing record bin values. The policy specifies the transaction timeout, record expiration and how the transaction is handled when the record already exists. This call works only for string and []byte values. If the policy is nil, the default relevant policy will be used.

func (*Client) PrependBins 

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

PrependBins works the same as Prepend, but avoids BinMap allocation and iteration.

func (*Client) Put 

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

Put writes record bin(s) to the server. The policy specifies the transaction timeout, record expiration and how the transaction is handled when the record already exists. If the policy is nil, the default relevant policy will be used.

func (*Client) PutBins 

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

PutBins writes record bin(s) to the server. The policy specifies the transaction timeout, record expiration and how the transaction is handled when the record already exists. This method avoids using the BinMap allocation and iteration and is lighter on GC. If the policy is nil, the default relevant policy will be used.

func (*Client) PutObject 

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

PutObject writes record bin(s) to the server. The policy specifies the transaction timeout, record expiration and how the transaction is handled when the record already exists. If the policy is nil, the default relevant policy will be used. A struct can be tagged to influence the way the object is put in the database: 

 type Person struct {
		TTL uint32 `asm:"ttl"`
		RecGen uint32 `asm:"gen"`
		Name string `as:"name"`
 		Address string `as:"desc,omitempty"`
 		Age uint8 `as:",omitempty"`
 		Password string `as:"-"`
 }

Tag `as:` denotes Aerospike fields. The first value will be the alias for the field. `,omitempty` (without any spaces between the comma and the word) will act like the json package, and will not send the value of the field to the database if the value is zero value. Tag `asm:` denotes Aerospike Meta fields, and includes ttl and generation values. If a tag is marked with `-`, it will not be sent to the database at all. Note: Tag `as` can be replaced with any other user-defined tag via the function `SetAerospikeTag`.

func (*Client) Query 

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

Query executes a query and returns a Recordset. The query executor puts records on the channel from separate goroutines. The caller can concurrently pop records off the channel through the Recordset.Records channel.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) QueryAggregate 

func (clnt *Client) QueryAggregate(policy *QueryPolicy, statement *Statement, packageName, functionName string, functionArgs ...Value) (*Recordset, Error)

QueryAggregate executes a Map/Reduce query and returns the results. The query executor puts records on the channel from separate goroutines. The caller can concurrently pop records off the channel through the Recordset.Records channel.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) QueryExecute 

func (clnt *Client) QueryExecute(policy *QueryPolicy,
	writePolicy *WritePolicy,
	statement *Statement,
	ops ...*Operation,
) (*ExecuteTask, Error)

QueryExecute applies operations on records that match the statement filter. Records are not returned to the client. This asynchronous server call will return before the command is complete. The user can optionally wait for command completion by using the returned ExecuteTask instance.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) QueryNode 

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

QueryNode executes a query on a specific node and returns a recordset. The caller can concurrently pop records off the channel through the record channel.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) QueryNodeObjects 

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

QueryNodeObjects executes a query on a specific node and marshals the records into the given channel. The caller can concurrently pop records off the channel.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) QueryObjects 

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

QueryObjects executes a query on all nodes in the cluster and marshals the records into the given channel. The query executor puts records on the channel from separate goroutines. The caller can concurrently pop objects.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) QueryPartitionObjects 

func (clnt *Client) QueryPartitionObjects(policy *QueryPolicy, statement *Statement, objChan interface{}, partitionFilter *PartitionFilter) (*Recordset, Error)

QueryPartitionObjects executes a query for specified partitions and returns a recordset. The query executor puts records on the channel from separate goroutines. The caller can concurrently pop records off the channel through the Recordset.Records channel.

This method is only supported by Aerospike 4.9+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) QueryPartitions 

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

QueryPartitions executes a query for specified partitions and returns a recordset. The query executor puts records on the channel from separate goroutines. The caller can concurrently pop records off the channel through the Recordset.Records channel.

This method is only supported by Aerospike 4.9+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) QueryRole 

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

QueryRole retrieves privileges for a given role.

func (*Client) QueryRoles 

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

QueryRoles retrieves all roles and their privileges.

func (*Client) QueryUser 

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

QueryUser retrieves roles for a given user.

func (*Client) QueryUsers 

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

QueryUsers retrieves all users and their roles.

func (*Client) RegisterUDF 

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

RegisterUDF registers a package containing user defined functions with server. This asynchronous server call will return before command is complete. The user can optionally wait for command completion by using the returned RegisterTask instance.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) RegisterUDFFromFile 

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

RegisterUDFFromFile reads a file from file system and registers the containing a package user defined functions with the server. This asynchronous server call will return before command is complete. The user can optionally wait for command completion by using the returned RegisterTask instance.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) RemoveUDF 

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

RemoveUDF removes a package containing user defined functions in the server. This asynchronous server call will return before command is complete. The user can optionally wait for command completion by using the returned RemoveTask instance.

This method is only supported by Aerospike 3+ servers. If the policy is nil, the default relevant policy will be used.

func (*Client) RevokePrivileges 

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

RevokePrivileges revokes privileges from a user-defined role.

func (*Client) RevokeRoles 

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

RevokeRoles removes roles from user's list of roles.

func (*Client) ScanAll 

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

ScanAll reads all records in specified namespace and set from all nodes. If the policy's concurrentNodes is specified, each server node will be read in parallel. Otherwise, server nodes are read sequentially. If the policy is nil, the default relevant policy will be used.

func (*Client) ScanAllObjects 

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

ScanAllObjects reads all records in specified namespace and set from all nodes. If the policy's concurrentNodes is specified, each server node will be read in parallel. Otherwise, server nodes are read sequentially. If the policy is nil, the default relevant policy will be used.

func (*Client) ScanNode 

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

ScanNode reads all records in specified namespace and set for one node only. If the policy is nil, the default relevant policy will be used.

func (*Client) ScanNodeObjects 

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

ScanNodeObjects reads all records in specified namespace and set for one node only, and marshalls the results into the objects of the provided channel in Recordset. If the policy is nil, the default relevant policy will be used. The resulting records will be marshalled into the objChan. objChan will be closed after all the records are read.

func (*Client) ScanPartitionObjects 

func (clnt *Client) ScanPartitionObjects(apolicy *ScanPolicy, objChan interface{}, partitionFilter *PartitionFilter, namespace string, setName string, binNames ...string) (*Recordset, Error)

ScanPartitionObjects Reads records in specified namespace, set and partition filter. If the policy's concurrentNodes is specified, each server node will be read in parallel. Otherwise, server nodes are read sequentially. If partitionFilter is nil, all partitions will be scanned. If the policy is nil, the default relevant policy will be used. This method is only supported by Aerospike 4.9+ servers.

func (*Client) ScanPartitions 

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

ScanPartitions Read records in specified namespace, set and partition filter. If the policy's concurrentNodes is specified, each server node will be read in parallel. Otherwise, server nodes are read sequentially. If partitionFilter is nil, all partitions will be scanned. If the policy is nil, the default relevant policy will be used. This method is only supported by Aerospike 4.9+ servers.

func (*Client) SetQuotas 

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

SetQuotas sets maximum reads/writes per second limits for a role. If a quota is zero, the limit is removed. Quotas require server security configuration "enable-quotas" to be set to true. Pass 0 for quota values for no limit.

func (*Client) SetWhitelist 

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

SetWhitelist sets IP address whitelist for a role. If whitelist is nil or empty, it removes existing whitelist from role.

func (*Client) SetXDRFilter 

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

SetXDRFilter sets XDR filter for given datacenter name and namespace. The expression filter indicates which records XDR should ship to the datacenter. Pass nil as filter to remove the currentl filter on the server.

func (*Client) Stats 

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

Stats returns internal statistics regarding the inner state of the client and the cluster.

func (*Client) String 

func (clnt *Client) String() string

String implements the Stringer interface for client

func (*Client) Touch 

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

Touch updates a record's metadata. If the record exists, the record's TTL will be reset to the policy's expiration. If the record doesn't exist, it will return an error.

func (*Client) Truncate 

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

Truncate removes records in specified namespace/set efficiently. This method is many orders of magnitude faster than deleting records one at a time. Works with Aerospike Server versions >= 3.12. This asynchronous server call may return before the truncation is complete. The user can still write new records after the server call returns because new records will have last update times greater than the truncate cutoff (set at the time of truncate call). For more information, See https://www.aerospike.com/docs/reference/info#truncate

func (*Client) WarmUp 

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

WarmUp fills the connection pool with connections for all nodes. This is necessary on startup for high traffic programs. If the count is <= 0, the connection queue will be filled. If the count is more than the size of the pool, the pool will be filled. Note: One connection per node is reserved for tend operations and is not used for transactions.

type ClientPolicy 

type ClientPolicy struct {
	// AuthMode specifies authentication mode used when user/password is defined. It is set to AuthModeInternal by default.
	AuthMode AuthMode

	// User authentication to cluster. Leave empty for clusters running without restricted access.
	User string

	// Password authentication to cluster. The password will be stored by the client and sent to server
	// in hashed format. Leave empty for clusters running without restricted access.
	Password string

	// ClusterName sets the expected cluster ID.  If not nil, server nodes must return this cluster ID in order to
	// join the client's view of the cluster. Should only be set when connecting to servers that
	// support the "cluster-name" info command. (v3.10+)
	ClusterName string //=""

	// Initial host connection timeout duration.  The timeout when opening a connection
	// to the server host for the first time.
	Timeout time.Duration //= 30 seconds

	// Connection idle timeout. Every time a connection is used, its idle
	// deadline will be extended by this duration. When this deadline is reached,
	// the connection will be closed and discarded from the connection pool.
	// The value is limited to 24 hours (86400s).
	//
	// It's important to set this value to a few seconds less than the server's proto-fd-idle-ms
	// (default 60000 milliseconds or 1 minute), so the client does not attempt to use a socket
	// that has already been reaped by the server.
	//
	// Connection pools are now implemented by a LIFO stack. Connections at the tail of the
	// stack will always be the least used. These connections are checked for IdleTimeout
	// on every tend (usually 1 second).
	//
	// Default: 55 seconds
	IdleTimeout time.Duration //= 55 seconds

	// LoginTimeout specifies the timeout for login operation for external authentication such as LDAP.
	LoginTimeout time.Duration //= 10 seconds

	// ConnectionQueueCache specifies the size of the Connection Queue cache PER NODE.
	// Note: One connection per node is reserved for tend operations and is not used for transactions.
	ConnectionQueueSize int //= 256

	// MinConnectionsPerNode specifies the minimum number of synchronous connections allowed per server node.
	// Preallocate min connections on client node creation.
	// The client will periodically allocate new connections if count falls below min connections.
	//
	// Server proto-fd-idle-ms may also need to be increased substantially if min connections are defined.
	// The proto-fd-idle-ms default directs the server to close connections that are idle for 60 seconds
	// which can defeat the purpose of keeping connections in reserve for a future burst of activity.
	//
	// If server proto-fd-idle-ms is changed, client ClientPolicy.IdleTimeout should also be
	// changed to be a few seconds less than proto-fd-idle-ms.
	//
	// Default: 0
	MinConnectionsPerNode int

	// MaxErrorRate defines the maximum number of errors allowed per node per ErrorRateWindow before
	// the circuit-breaker algorithm returns MAX_ERROR_RATE on database commands to that node.
	// If MaxErrorRate is zero, there is no error limit and
	// the exception will never be thrown.
	//
	// The counted error types are any error that causes the connection to close (socket errors
	// and client timeouts) and types.ResultCode.DEVICE_OVERLOAD.
	//
	// Default: 0
	MaxErrorRate int

	// ErrorRateWindow defined the number of cluster tend iterations that defines the window for MaxErrorRate.
	// One tend iteration is defined as TendInterval plus the time to tend all nodes.
	// At the end of the window, the error count is reset to zero and backoff state is removed
	// on all nodes.
	//
	// Default: 1
	ErrorRateWindow int //= 1

	// If set to true, will not create a new connection
	// to the node if there are already `ConnectionQueueSize` active connections.
	// Note: One connection per node is reserved for tend operations and is not used for transactions.
	LimitConnectionsToQueueSize bool //= true

	// Number of connections allowed to established at the same time.
	// This value does not limit the number of connections. It just
	// puts a threshold on the number of parallel opening connections.
	// By default, there are no limits.
	OpeningConnectionThreshold int // 0

	// Throw exception if host connection fails during addHost().
	FailIfNotConnected bool //= true

	// TendInterval determines interval for checking for cluster state changes.
	// Minimum possible interval is 10 Milliseconds.
	TendInterval time.Duration //= 1 second

	// A IP translation table is used in cases where different clients
	// use different server IP addresses.  This may be necessary when
	// using clients from both inside and outside a local area
	// network. Default is no translation.
	// The key is the IP address returned from friend info requests to other servers.
	// The value is the real IP address used to connect to the server.
	IpMap map[string]string

	// UseServicesAlternate determines if the client should use "services-alternate" instead of "services"
	// in info request during cluster tending.
	//"services-alternate" returns server configured external IP addresses that client
	// uses to talk to nodes.  "services-alternate" can be used in place of providing a client "ipMap".
	// This feature is recommended instead of using the client-side IpMap above.
	//
	// "services-alternate" is available with Aerospike Server versions >= 3.7.1.
	UseServicesAlternate bool // false

	// RackAware directs the client to update rack information on intervals.
	// When this feature is enabled, the client will prefer to use nodes which reside
	// on the same rack as the client for read transactions. The application should also set the RackId, and
	// use the ReplicaPolicy.PREFER_RACK for reads.
	// This feature is in particular useful if the cluster is in the cloud and the cloud provider
	// is charging for network bandwidth out of the zone. Keep in mind that the node on the same rack
	// may not be the Master, and as such the data may be stale. This setting is particularly usable
	// for clusters that are read heavy.
	RackAware bool // false

	// RackId defines the Rack the application is on. This will only influence reads if Rackaware is enabled on the client,
	// and configured on the server.
	// If RackIds is set, this value will be ignored.
	// Note: This attribute is deprecated and will be removed in future versions.
	RackId int // 0

	// RackIds defines the list of acceptable racks in order of preference. Nodes in RackIds[0] are chosen first.
	// If a node is not found in rackIds[0], then nodes in rackIds[1] are searched, and so on.
	// If rackIds is set, ClientPolicy.RackId is ignored.
	//
	// ClientPolicy.RackAware, ReplicaPolicy.PREFER_RACK and server rack
	// configuration must also be set to enable this functionality.
	RackIds []int // nil

	// TlsConfig specifies TLS secure connection policy for TLS enabled servers.
	// For better performance, we suggest preferring the server-side ciphers by
	// setting PreferServerCipherSuites = true.
	TlsConfig *tls.Config //= nil

	// IgnoreOtherSubnetAliases helps to ignore aliases that are outside main subnet
	IgnoreOtherSubnetAliases bool //= false
}

ClientPolicy encapsulates parameters for client policy command.

func NewClientPolicy 

func NewClientPolicy() *ClientPolicy

NewClientPolicy generates a new ClientPolicy with default values.

func (*ClientPolicy) RequiresAuthentication 

func (cp *ClientPolicy) RequiresAuthentication() bool

RequiresAuthentication returns true if a User or Password is set for ClientPolicy.

type Cluster 

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

Cluster encapsulates the aerospike cluster nodes and manages them.

func (*Cluster) AddSeeds 

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

AddSeeds adds new hosts to the cluster. They will be added to the cluster on next tend call.

func (*Cluster) ClientPolicy 

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

ClientPolicy returns the client policy that is currently used with the cluster.

func (*Cluster) Close 

func (clstr *Cluster) Close()

Close closes all cached connections to the cluster nodes and stops the tend goroutine.

func (*Cluster) GetAliases 

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

GetAliases returns a list of all node aliases in the cluster

func (*Cluster) GetNodeByName 

func (clstr *Cluster) GetNodeByName(nodeName string) (*Node, Error)

GetNodeByName finds a node by name and returns an error if the node is not found.

func (*Cluster) GetNodes 

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

GetNodes returns a list of all nodes in the cluster

func (*Cluster) GetRandomNode 

func (clstr *Cluster) GetRandomNode() (*Node, Error)

GetRandomNode returns a random node on the cluster

func (*Cluster) GetSeeds 

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

GetSeeds returns a list of all seed nodes in the cluster

func (*Cluster) Healthy 

func (clstr *Cluster) Healthy() Error

Healthy returns an error if the cluster is not healthy.

func (*Cluster) IsConnected 

func (clstr *Cluster) IsConnected() bool

IsConnected returns true if cluster has nodes and is not already closed.

func (*Cluster) MigrationInProgress 

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

MigrationInProgress determines if any node in the cluster is participating in a data migration

func (*Cluster) Password 

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

Password returns the password that is currently used with the cluster.

func (*Cluster) String 

func (clstr *Cluster) String() string

String implements the stringer interface

func (*Cluster) WaitUntillMigrationIsFinished 

func (clstr *Cluster) WaitUntillMigrationIsFinished(timeout time.Duration) Error

WaitUntillMigrationIsFinished will block until all migration operations in the cluster all finished.

func (*Cluster) WarmUp 

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

WarmUp fills the connection pool with connections for all nodes. This is necessary on startup for high traffic programs. If the count is <= 0, the connection queue will be filled. If the count is more than the size of the pool, the pool will be filled. Note: One connection per node is reserved for tend operations and is not used for transactions.

type CommitLevel 

type CommitLevel int

CommitLevel indicates the desired consistency guarantee when committing a transaction on the server. 

const (
	// COMMIT_ALL indicates the server should wait until successfully committing master and all replicas.
	COMMIT_ALL CommitLevel = iota

	// COMMIT_MASTER indicates the server should wait until successfully committing master only.
	COMMIT_MASTER
)

type Connection 

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

Connection represents a connection with a timeout.

func (*Connection) Close 

func (ctn *Connection) Close()

Close closes the connection

func (*Connection) IsConnected 

func (ctn *Connection) IsConnected() bool

IsConnected returns true if the connection is not closed yet.

func (*Connection) Login 

func (ctn *Connection) Login(policy *ClientPolicy) Error

Login will send authentication information to the server. This function is provided for using the connection in conjunction with external libraries. The password will be hashed everytime, which is a slow operation.

func (*Connection) Read 

func (ctn *Connection) Read(buf []byte, length int) (total int, aerr Error)

Read reads from connection buffer to the provided slice.

func (*Connection) RequestInfo 

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

RequestInfo gets info values by name from the specified connection. Timeout should already be set on the connection.

func (*Connection) SetTimeout 

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

SetTimeout sets connection timeout for both read and write operations.

func (*Connection) Write 

func (ctn *Connection) Write(buf []byte) (total int, aerr Error)

Write writes the slice to the connection buffer.

type DropIndexTask 

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

DropIndexTask is used to poll for long running create index completion.

func NewDropIndexTask 

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

NewDropIndexTask initializes a task with fields needed to query server nodes.

func (*DropIndexTask) IsDone 

func (tski *DropIndexTask) IsDone() (bool, Error)

IsDone queries all nodes for task completion status.

func (*DropIndexTask) OnComplete 

func (tski *DropIndexTask) OnComplete() chan Error

OnComplete returns a channel that will be closed as soon as the task is finished. If an error is encountered during operation, an error will be sent on the channel.

type Error 

type Error interface {
	error

	// Matches will return true is the ResultCode of the error or
	// any of the errors wrapped down the chain has any of the
	// provided codes.
	Matches(rcs ...types.ResultCode) bool

	// Unwrap returns the error inside
	Unwrap() error

	// Trace returns a stack trace of where the error originates from
	Trace() string
	// contains filtered or unexported methods
}

Error is the internal error interface for the Aerospike client's errors. All the public API return this error type. This interface is compatible with error interface, including errors.Is and errors.As.

func PackBool 

func PackBool(cmd BufferEx, val bool) (int, Error)

PackBool packs a bool value

func PackBytes 

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

PackBytes backs a byte array

func PackFloat32 

func PackFloat32(cmd BufferEx, val float32) (int, Error)

PackFloat32 packs float32 value

func PackFloat64 

func PackFloat64(cmd BufferEx, val float64) (int, Error)

PackFloat64 packs float64 value

func PackInt64 

func PackInt64(cmd BufferEx, val int64) (int, Error)

PackInt64 packs an int64

func PackJson 

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

PackJson packs json data

func PackList 

func PackList(cmd BufferEx, list ListIter) (int, Error)

PackList packs any slice that implement the ListIter interface

func PackMap 

func PackMap(cmd BufferEx, theMap MapIter) (int, Error)

PackMap packs any map that implements the MapIter interface

func PackNil 

func PackNil(cmd BufferEx) (int, Error)

PackNil packs a nil value

func PackString 

func PackString(cmd BufferEx, val string) (int, Error)

PackString packs a string

func PackUInt64 

func PackUInt64(cmd BufferEx, val uint64) (int, Error)

PackUInt64 packs a uint64

type ExecuteTask 

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

ExecuteTask is used to poll for long running server execute job completion.

func NewExecuteTask 

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

NewExecuteTask initializes task with fields needed to query server nodes.

func (*ExecuteTask) IsDone 

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

IsDone queries all nodes for task completion status.

func (*ExecuteTask) OnComplete 

func (etsk *ExecuteTask) OnComplete() chan Error

OnComplete returns a channel which will be closed when the task is completed. If an error is encountered while performing the task, an error will be sent on the channel.

type ExpReadFlags 

type ExpReadFlags int

ExpReadFlags is used to change mode in expression reads. 

const (
	// ExpReadFlagDefault is the default
	ExpReadFlagDefault ExpReadFlags = 0

	// ExpReadFlagEvalNoFail means:
	// Ignore failures caused by the expression resolving to unknown or a non-bin type.
	ExpReadFlagEvalNoFail ExpReadFlags = 1 << 4
)

type ExpRegexFlags 

type ExpRegexFlags int

ExpRegexFlags is used to change the Regex Mode in Expression Filters. 

const (
	// ExpRegexFlagNONE uses regex defaults.
	ExpRegexFlagNONE ExpRegexFlags = 0

	// ExpRegexFlagEXTENDED uses POSIX Extended Regular Expression syntax when interpreting regex.
	ExpRegexFlagEXTENDED ExpRegexFlags = 1 << 0

	// ExpRegexFlagICASE does not differentiate cases.
	ExpRegexFlagICASE ExpRegexFlags = 1 << 1

	// ExpRegexFlagNOSUB does not report position of matches.
	ExpRegexFlagNOSUB ExpRegexFlags = 1 << 2

	// ExpRegexFlagNEWLINE does not Match-any-character operators don't match a newline.
	ExpRegexFlagNEWLINE ExpRegexFlags = 1 << 3
)

type ExpType 

type ExpType uint

ExpType defines the expression's data type. 

var (
	// ExpTypeNIL is NIL Expression Type
	ExpTypeNIL ExpType = 0
	// ExpTypeBOOL is BOOLEAN Expression Type
	ExpTypeBOOL ExpType = 1
	// ExpTypeINT is INTEGER Expression Type
	ExpTypeINT ExpType = 2
	// ExpTypeSTRING is STRING Expression Type
	ExpTypeSTRING ExpType = 3
	// ExpTypeLIST is LIST Expression Type
	ExpTypeLIST ExpType = 4
	// ExpTypeMAP is MAP Expression Type
	ExpTypeMAP ExpType = 5
	// ExpTypeBLOB is BLOB Expression Type
	ExpTypeBLOB ExpType = 6
	// ExpTypeFLOAT is FLOAT Expression Type
	ExpTypeFLOAT ExpType = 7
	// ExpTypeGEO is GEO String Expression Type
	ExpTypeGEO ExpType = 8
	// ExpTypeHLL is HLL Expression Type
	ExpTypeHLL ExpType = 9
)

type ExpWriteFlags 

type ExpWriteFlags int

ExpWriteFlags is used to change mode in expression writes. 

const (
	// ExpWriteFlagDefault is the default. Allows create or update.
	ExpWriteFlagDefault ExpWriteFlags = 0

	// ExpWriteFlagCreateOnly means:
	// If bin does not exist, a new bin will be created.
	// If bin exists, the operation will be denied.
	// If bin exists, fail with Bin Exists
	ExpWriteFlagCreateOnly ExpWriteFlags = 1 << 0

	// ExpWriteFlagUpdateOnly means:
	// If bin exists, the bin will be overwritten.
	// If bin does not exist, the operation will be denied.
	// If bin does not exist, fail with Bin Not Found
	ExpWriteFlagUpdateOnly ExpWriteFlags = 1 << 1

	// ExpWriteFlagAllowDelete means:
	// If expression results in nil value, then delete the bin.
	// Otherwise, return OP Not Applicable when NoFail is not set
	ExpWriteFlagAllowDelete ExpWriteFlags = 1 << 2

	// ExpWriteFlagPolicyNoFail means:
	// Do not raise error if operation is denied.
	ExpWriteFlagPolicyNoFail ExpWriteFlags = 1 << 3

	// ExpWriteFlagEvalNoFail means:
	// Ignore failures caused by the expression resolving to unknown or a non-bin type.
	ExpWriteFlagEvalNoFail ExpWriteFlags = 1 << 4
)

Expression write Flags

type Expression 

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

Expression which can be applied to most commands, to control which records are affected by the command.

func ExpAnd 

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

ExpAnd creates a "and" (&&) operator that applies to a variable number of expressions.

func ExpBinExists 

func ExpBinExists(name string) *Expression

ExpBinExists creates a function that returns if bin of specified name exists.

func ExpBinType 

func ExpBinType(name string) *Expression

ExpBinType creates a function that returns bin's integer particle type.

func ExpBitAdd 

func ExpBitAdd(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	value *Expression,
	signed bool,
	action BitOverflowAction,
	bin *Expression,
) *Expression

ExpBitAdd creates an expression that adds value to []byte bin starting at bitOffset for bitSize and returns []byte. `BitSize` must be <= 64. Signed indicates if bits should be treated as a signed number. If add overflows/underflows, `BitOverflowAction` is used.

func ExpBitAnd 

func ExpBitAnd(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	value *Expression,
	bin *Expression,
) *Expression

ExpBitAnd creates an expression that performs bitwise "and" on value and []byte bin at bitOffset for bitSize and returns []byte. 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 23
bitSize = 9
value = [0b00111100, 0b10000000]
bin result = [0b00000001, 0b01000010, 0b00000010, 0b00000000, 0b00000101]

func ExpBitCount 

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

ExpBitCount creates an expression that returns integer count of set bits from []byte bin starting at bitOffset for bitSize.

func ExpBitGet 

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

ExpBitGet creates an expression that returns bits from []byte bin starting at bitOffset for bitSize.

func ExpBitGetInt 

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

ExpBitGetInt Create expression that returns integer from []byte bin starting at bitOffset for bitSize. Signed indicates if bits should be treated as a signed number.

func ExpBitInsert 

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

ExpBitInsert creates an expression that inserts value bytes into []byte bin at byteOffset and returns []byte.

func ExpBitLScan 

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

ExpBitLScan creates an expression that returns integer bit offset of the first specified value bit in []byte bin starting at bitOffset for bitSize.

func ExpBitLShift 

func ExpBitLShift(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	shift *Expression,
	bin *Expression,
) *Expression

ExpBitLShift creates an expression that shifts left []byte bin starting at bitOffset for bitSize and returns []byte.

func ExpBitNot 

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

ExpBitNot creates an expression that negates []byte bin starting at bitOffset for bitSize and returns []byte.

func ExpBitOr 

func ExpBitOr(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	value *Expression,
	bin *Expression,
) *Expression

ExpBitOr creates an expression that performs bitwise "or" on value and []byte bin at bitOffset for bitSize and returns []byte.

func ExpBitRScan 

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

ExpBitRScan creates an expression that returns integer bit offset of the last specified value bit in []byte bin starting at bitOffset for bitSize.

func ExpBitRShift 

func ExpBitRShift(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	shift *Expression,
	bin *Expression,
) *Expression

ExpBitRShift creates an expression that shifts right []byte bin starting at bitOffset for bitSize and returns []byte.

func ExpBitRemove 

func ExpBitRemove(
	policy *BitPolicy,
	byteOffset *Expression,
	byteSize *Expression,
	bin *Expression,
) *Expression

ExpBitRemove creates an expression that removes bytes from []byte bin at byteOffset for byteSize and returns []byte.

func ExpBitResize 

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

ExpBitResize creates an expression that resizes []byte to byteSize according to resizeFlags and returns []byte.

func ExpBitSet 

func ExpBitSet(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	value *Expression,
	bin *Expression,
) *Expression

ExpBitSet creates an expression that sets value on []byte bin at bitOffset for bitSize and returns []byte.

func ExpBitSetInt 

func ExpBitSetInt(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	value *Expression,
	bin *Expression,
) *Expression

ExpBitSetInt creates an expression that sets value to []byte bin starting at bitOffset for bitSize and returns []byte. `BitSize` must be <= 64.

func ExpBitSubtract 

func ExpBitSubtract(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	value *Expression,
	signed bool,
	action BitOverflowAction,
	bin *Expression,
) *Expression

ExpBitSubtract creates an expression that subtracts value from []byte bin starting at bitOffset for bitSize and returns []byte. `BitSize` must be <= 64. Signed indicates if bits should be treated as a signed number. If add overflows/underflows, `BitOverflowAction` is used.

func ExpBitXor 

func ExpBitXor(
	policy *BitPolicy,
	bitOffset *Expression,
	bitSize *Expression,
	value *Expression,
	bin *Expression,
) *Expression

ExpBitXor creates an expression that performs bitwise "xor" on value and []byte bin at bitOffset for bitSize and returns []byte.

func ExpBlobBin 

func ExpBlobBin(name string) *Expression

ExpBlobBin creates a blob bin expression.

func ExpBlobVal 

func ExpBlobVal(val []byte) *Expression

ExpBlobVal creates a Blob bin value

func ExpBoolBin 

func ExpBoolBin(name string) *Expression

ExpBoolBin creates a boolean bin expression.

func ExpBoolVal 

func ExpBoolVal(val bool) *Expression

ExpBoolVal creates a Boolean value

func ExpCond 

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

ExpCond will conditionally select an expression from a variable number of expression pairs followed by default expression action. Requires server version 5.6.0+.

func ExpDef 

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

ExpDef will assign variable to an expression that can be accessed later. Requires server version 5.6.0+.

func ExpDeviceSize 

func ExpDeviceSize() *Expression

ExpDeviceSize creates a function that returns record size on disk. If server storage-engine is memory, then zero is returned.

func ExpDigestModulo 

func ExpDigestModulo(modulo int64) *Expression

ExpDigestModulo creates a function that returns record digest modulo as integer.

func ExpEq 

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

ExpEq creates a equal (==) expression.

func ExpExclusive 

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

ExpExclusive creates an expression that returns true if only one of the expressions are true. Requires server version 5.6.0+.

func ExpFloatBin 

func ExpFloatBin(name string) *Expression

ExpFloatBin creates a 64 bit float bin expression.

func ExpFloatVal 

func ExpFloatVal(val float64) *Expression

ExpFloatVal creates a 64 bit float bin value

func ExpGeoBin 

func ExpGeoBin(name string) *Expression

ExpGeoBin creates a geo bin expression.

func ExpGeoCompare 

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

ExpGeoCompare creates a compare geospatial operation.

func ExpGeoVal 

func ExpGeoVal(val string) *Expression

ExpGeoVal creates a geospatial json string value.

func ExpGreater 

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

ExpGreater creates a greater than (>) operation.

func ExpGreaterEq 

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

ExpGreaterEq creates a greater than or equal (>=) operation.

func ExpHLLAdd 

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

ExpHLLAdd creates an expression that adds list values to a HLL set and returns HLL set. The function assumes HLL bin already exists.

func ExpHLLAddWithIndex 

func ExpHLLAddWithIndex(
	policy *HLLPolicy,
	list *Expression,
	indexBitCount *Expression,
	bin *Expression,
) *Expression

ExpHLLAddWithIndex creates an expression that adds values to a HLL set and returns HLL set. If HLL bin does not exist, use `indexBitCount` to create HLL bin.

func ExpHLLAddWithIndexAndMinHash 

func ExpHLLAddWithIndexAndMinHash(
	policy *HLLPolicy,
	list *Expression,
	indexBitCount *Expression,
	minHashCount *Expression,
	bin *Expression,
) *Expression

ExpHLLAddWithIndexAndMinHash creates an expression that adds values to a HLL set and returns HLL set. If HLL bin does not exist, use `indexBitCount` and `minHashBitCount` to create HLL set.

func ExpHLLBin 

func ExpHLLBin(name string) *Expression

ExpHLLBin creates a a HLL bin expression

func ExpHLLDescribe 

func ExpHLLDescribe(bin *Expression) *Expression

ExpHLLDescribe creates an expression that returns `indexBitCount` and `minHashBitCount` used to create HLL bin in a list of longs. `list[0]` is `indexBitCount` and `list[1]` is `minHashBitCount`.

func ExpHLLGetCount 

func ExpHLLGetCount(bin *Expression) *Expression

ExpHLLGetCount creates an expression that returns estimated number of elements in the HLL bin.

func ExpHLLGetIntersectCount 

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

ExpHLLGetIntersectCount creates an expression that returns estimated number of elements that would be contained by the intersection of these HLL objects.

func ExpHLLGetSimilarity 

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

ExpHLLGetSimilarity creates an expression that returns estimated similarity of these HLL objects as a 64 bit float.

func ExpHLLGetUnion 

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

ExpHLLGetUnion creates an expression that returns a HLL object that is the union of all specified HLL objects in the list with the HLL bin.

func ExpHLLGetUnionCount 

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

ExpHLLGetUnionCount creates an expression that returns estimated number of elements that would be contained by the union of these HLL objects.

func ExpHLLInit 

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

ExpHLLInit creates expression that creates a new HLL or resets an existing HLL.

func ExpHLLInitWithMinHash 

func ExpHLLInitWithMinHash(
	policy *HLLPolicy,
	indexBitCount *Expression,
	minHashCount *Expression,
	bin *Expression,
) *Expression

ExpHLLInitWithMinHash creates expression that creates a new HLL or resets an existing HLL with minhash bits.

func ExpHLLMayContain 

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

ExpHLLMayContain creates an expression that returns one if HLL bin may contain all items in the list.

func ExpIntARShift 

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

ExpIntARShift creates integer "arithmetic right shift" (>>) operator. The sign bit is preserved and not shifted. Requires server version 5.6.0+.

func ExpIntAnd 

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

ExpIntAnd creates integer "and" (&) operator that is applied to two or more integers. All arguments must resolve to integers. Requires server version 5.6.0+.

func ExpIntBin 

func ExpIntBin(name string) *Expression

ExpIntBin creates a 64 bit int bin expression.

func ExpIntCount 

func ExpIntCount(exp *Expression) *Expression

ExpIntCount creates expression that returns count of integer bits that are set to 1. Requires server version 5.6.0+.

func ExpIntLScan 

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

ExpIntLScan creates expression that scans integer bits from left (most significant bit) to right (least significant bit), looking for a search bit value. When the search value is found, the index of that bit (where the most significant bit is index 0) is returned. If "search" is true, the scan will search for the bit value 1. If "search" is false it will search for bit value 0. Requires server version 5.6.0+.

func ExpIntLShift 

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

ExpIntLShift creates integer "left shift" (<<) operator. Requires server version 5.6.0+.

func ExpIntNot 

func ExpIntNot(exp *Expression) *Expression

ExpIntNot creates integer "not" (~) operator. Requires server version 5.6.0+.

func ExpIntOr 

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

ExpIntOr creates integer "or" (|) operator that is applied to two or more integers. All arguments must resolve to integers. Requires server version 5.6.0+.

func ExpIntRScan 

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

ExpIntRScan creates expression that scans integer bits from right (least significant bit) to left (most significant bit), looking for a search bit value. When the search value is found, the index of that bit (where the most significant bit is index 0) is returned. If "search" is true, the scan will search for the bit value 1. If "search" is false it will search for bit value 0. Requires server version 5.6.0+.

func ExpIntRShift 

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

ExpIntRShift creates integer "logical right shift" (>>>) operator. Requires server version 5.6.0+.

func ExpIntVal 

func ExpIntVal(val int64) *Expression

ExpIntVal creates a 64 bit integer value

func ExpIntXor 

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

ExpIntXor creates integer "xor" (^) operator that is applied to two or more integers. All arguments must resolve to integers. Requires server version 5.6.0+.

func ExpIsTombstone 

func ExpIsTombstone() *Expression

ExpIsTombstone creates a expression that returns if record has been deleted and is still in tombstone state. This expression usually evaluates quickly because record meta data is cached in memory.

func ExpKey 

func ExpKey(expType ExpType) *Expression

ExpKey creates a record key expression of specified type.

func ExpKeyExists 

func ExpKeyExists() *Expression

ExpKeyExists creates a function that returns if the primary key is stored in the record meta data as a boolean expression. This would occur when `send_key` is true on record write.

func ExpLastUpdate 

func ExpLastUpdate() *Expression

ExpLastUpdate creates a function that returns record last update time expressed as 64 bit integer nanoseconds since 1970-01-01 epoch.

func ExpLess 

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

ExpLess creates a less than (<) operation.

func ExpLessEq 

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

ExpLessEq creates a less than or equals (<=) operation.

func ExpLet 

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

ExpLet will define variables and expressions in scope. Requires server version 5.6.0+.

func ExpListAppend 

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

ExpListAppend creates an expression that appends value to end of list.

func ExpListAppendItems 

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

ExpListAppendItems creates an expression that appends list items to end of list.

func ExpListBin 

func ExpListBin(name string) *Expression

ExpListBin creates a list bin expression.

func ExpListClear 

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

ExpListClear creates an expression that removes all items in list.

func ExpListGetByIndex 

func ExpListGetByIndex(
	returnType ListReturnType,
	valueType ExpType,
	index *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListGetByIndex creates an expression that selects list item identified by index and returns selected data specified by returnType.

func ExpListGetByIndexRange 

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

ExpListGetByIndexRange creates an expression that selects list items starting at specified index to the end of list and returns selected data specified by returnType .

func ExpListGetByIndexRangeCount 

func ExpListGetByIndexRangeCount(
	returnType ListReturnType,
	index *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListGetByIndexRangeCount creates an expression that selects "count" list items starting at specified index and returns selected data specified by returnType.

func ExpListGetByRank 

func ExpListGetByRank(
	returnType ListReturnType,
	valueType ExpType,
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListGetByRank creates an expression that selects list item identified by rank and returns selected data specified by returnType.

func ExpListGetByRankRange 

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

ExpListGetByRankRange creates an expression that selects list items starting at specified rank to the last ranked item and returns selected data specified by returnType.

func ExpListGetByRankRangeCount 

func ExpListGetByRankRangeCount(
	returnType ListReturnType,
	rank *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListGetByRankRangeCount creates an expression that selects "count" list items starting at specified rank and returns selected data specified by returnType.

func ExpListGetByValue 

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

ExpListGetByValue creates an expression that selects list items identified by value and returns selected data specified by returnType.

func ExpListGetByValueList 

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

ExpListGetByValueList creates an expression that selects list items identified by values and returns selected data specified by returnType.

func ExpListGetByValueRange 

func ExpListGetByValueRange(
	returnType ListReturnType,
	valueBegin *Expression,
	valueEnd *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListGetByValueRange creates an expression that selects list items identified by value range and returns selected data specified by returnType.

func ExpListGetByValueRelativeRankRange 

func ExpListGetByValueRelativeRankRange(
	returnType ListReturnType,
	value *Expression,
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListGetByValueRelativeRankRange creates an expression that selects list items nearest to value and greater by relative rank and returns selected data specified by returnType.

Examples for ordered list \[0, 4, 5, 9, 11, 15\]: 

(value,rank) = [selected items]
(5,0) = [5,9,11,15]
(5,1) = [9,11,15]
(5,-1) = [4,5,9,11,15]
(3,0) = [4,5,9,11,15]
(3,3) = [11,15]
(3,-3) = [0,4,5,9,11,15]

func ExpListGetByValueRelativeRankRangeCount 

func ExpListGetByValueRelativeRankRangeCount(
	returnType ListReturnType,
	value *Expression,
	rank *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListGetByValueRelativeRankRangeCount creates an expression that selects list items nearest to value and greater by relative rank with a count limit and returns selected data specified by returnType.

Examples for ordered list \[0, 4, 5, 9, 11, 15\]: 

(value,rank,count) = [selected items]
(5,0,2) = [5,9]
(5,1,1) = [9]
(5,-1,2) = [4,5]
(3,0,1) = [4]
(3,3,7) = [11,15]
(3,-3,2) = []

func ExpListIncrement 

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

ExpListIncrement creates an expression that increments `list[index]` by value. Value expression should resolve to a number.

func ExpListInsert 

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

ExpListInsert creates an expression that inserts value to specified index of list.

func ExpListInsertItems 

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

ExpListInsertItems creates an expression that inserts each input list item starting at specified index of list.

func ExpListRemoveByIndex 

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

ExpListRemoveByIndex creates an expression that removes list item identified by index.

func ExpListRemoveByIndexRange 

func ExpListRemoveByIndexRange(
	index *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByIndexRange creates an expression that removes list items starting at specified index to the end of list.

func ExpListRemoveByIndexRangeCount 

func ExpListRemoveByIndexRangeCount(
	index *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByIndexRangeCount creates an expression that removes "count" list items starting at specified index.

func ExpListRemoveByRank 

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

ExpListRemoveByRank creates an expression that removes list item identified by rank.

func ExpListRemoveByRankRange 

func ExpListRemoveByRankRange(
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByRankRange creates an expression that removes list items starting at specified rank to the last ranked item.

func ExpListRemoveByRankRangeCount 

func ExpListRemoveByRankRangeCount(
	rank *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByRankRangeCount creates an expression that removes "count" list items starting at specified rank.

func ExpListRemoveByValue 

func ExpListRemoveByValue(
	value *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByValue creates an expression that removes list items identified by value.

func ExpListRemoveByValueList 

func ExpListRemoveByValueList(
	values *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByValueList creates an expression that removes list items identified by values.

func ExpListRemoveByValueRange 

func ExpListRemoveByValueRange(
	valueBegin *Expression,
	valueEnd *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByValueRange creates an expression that removes list items identified by value range (valueBegin inclusive, valueEnd exclusive). If valueBegin is nil, the range is less than valueEnd. If valueEnd is nil, the range is greater than equal to valueBegin.

func ExpListRemoveByValueRelativeRankRange 

func ExpListRemoveByValueRelativeRankRange(
	value *Expression,
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByValueRelativeRankRange creates an expression that removes list items nearest to value and greater by relative rank.

Examples for ordered list \[0, 4, 5, 9, 11, 15\]: 

(value,rank) = [removed items]
(5,0) = [5,9,11,15]
(5,1) = [9,11,15]
(5,-1) = [4,5,9,11,15]
(3,0) = [4,5,9,11,15]
(3,3) = [11,15]
(3,-3) = [0,4,5,9,11,15]

func ExpListRemoveByValueRelativeRankRangeCount 

func ExpListRemoveByValueRelativeRankRangeCount(
	value *Expression,
	rank *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpListRemoveByValueRelativeRankRangeCount creates an expression that removes list items nearest to value and greater by relative rank with a count limit.

Examples for ordered list \[0, 4, 5, 9, 11, 15\]: 

(value,rank,count) = [removed items]
(5,0,2) = [5,9]
(5,1,1) = [9]
(5,-1,2) = [4,5]
(3,0,1) = [4]
(3,3,7) = [11,15]
(3,-3,2) = []

func ExpListSet 

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

ExpListSet creates an expression that sets item value at specified index in list.

func ExpListSize 

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

ExpListSize creates an expression that returns list size.

func ExpListSort 

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

ExpListSort creates an expression that sorts list according to sortFlags.

func ExpListVal 

func ExpListVal(val ...Value) *Expression

ExpListVal creates a List bin Value

func ExpListValueVal 

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

ExpListValueVal creates a List bin Value

func ExpMapBin 

func ExpMapBin(name string) *Expression

ExpMapBin creates a map bin expression.

func ExpMapClear 

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

ExpMapClear creates an expression that removes all items in map.

func ExpMapGetByIndex 

func ExpMapGetByIndex(
	returnType mapReturnType,
	valueType ExpType,
	index *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByIndex creates an expression that selects map item identified by index and returns selected data specified by returnType.

func ExpMapGetByIndexRange 

func ExpMapGetByIndexRange(
	returnType mapReturnType,
	index *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByIndexRange creates an expression that selects map items starting at specified index to the end of map and returns selected data specified by returnType.

func ExpMapGetByIndexRangeCount 

func ExpMapGetByIndexRangeCount(
	returnType mapReturnType,
	index *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByIndexRangeCount creates an expression that selects "count" map items starting at specified index and returns selected data specified by returnType.

func ExpMapGetByKey 

func ExpMapGetByKey(
	returnType mapReturnType,
	valueType ExpType,
	key *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByKey creates an expression that selects map item identified by key and returns selected data specified by returnType.

func ExpMapGetByKeyList 

func ExpMapGetByKeyList(
	returnType mapReturnType,
	keys *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByKeyList creates an expression that selects map items identified by keys and returns selected data specified by returnType

func ExpMapGetByKeyRange 

func ExpMapGetByKeyRange(
	returnType mapReturnType,
	keyBegin *Expression,
	keyEnd *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByKeyRange creates an expression that selects map items identified by key range (keyBegin inclusive, keyEnd exclusive). If keyBegin is nil, the range is less than keyEnd. If keyEnd is nil, the range is greater than equal to keyBegin. Expression returns selected data specified by returnType.

func ExpMapGetByKeyRelativeIndexRange 

func ExpMapGetByKeyRelativeIndexRange(
	returnType mapReturnType,
	key *Expression,
	index *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByKeyRelativeIndexRange creates an expression that selects map items nearest to key and greater by index. Expression returns selected data specified by returnType.

Examples for ordered map [{0=17},{4=2},{5=15},{9=10}]:

* (value,index) = [selected items] * (5,0) = [{5=15},{9=10}] * (5,1) = [{9=10}] * (5,-1) = [{4=2},{5=15},{9=10}] * (3,2) = [{9=10}] * (3,-2) = [{0=17},{4=2},{5=15},{9=10}]

func ExpMapGetByKeyRelativeIndexRangeCount 

func ExpMapGetByKeyRelativeIndexRangeCount(
	returnType mapReturnType,
	key *Expression,
	index *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByKeyRelativeIndexRangeCount creates an expression that selects map items nearest to key and greater by index with a count limit. Expression returns selected data specified by returnType.

Examples for ordered map [{0=17},{4=2},{5=15},{9=10}]:

* (value,index,count) = [selected items] * (5,0,1) = [{5=15}] * (5,1,2) = [{9=10}] * (5,-1,1) = [{4=2}] * (3,2,1) = [{9=10}] * (3,-2,2) = [{0=17}]

func ExpMapGetByRank 

func ExpMapGetByRank(
	returnType mapReturnType,
	valueType ExpType,
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByRank creates an expression that selects map item identified by rank and returns selected data specified by returnType.

func ExpMapGetByRankRange 

func ExpMapGetByRankRange(
	returnType mapReturnType,
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByRankRange creates an expression that selects map items starting at specified rank to the last ranked item and returns selected data specified by returnType.

func ExpMapGetByRankRangeCount 

func ExpMapGetByRankRangeCount(
	returnType mapReturnType,
	rank *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByRankRangeCount creates an expression that selects "count" map items starting at specified rank and returns selected data specified by returnType.

func ExpMapGetByValue 

func ExpMapGetByValue(
	returnType mapReturnType,
	value *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByValue creates an expression that selects map items identified by value and returns selected data specified by returnType.

func ExpMapGetByValueList 

func ExpMapGetByValueList(
	returnType mapReturnType,
	values *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByValueList creates an expression that selects map items identified by values and returns selected data specified by returnType.

func ExpMapGetByValueRange 

func ExpMapGetByValueRange(
	returnType mapReturnType,
	valueBegin *Expression,
	valueEnd *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByValueRange creates an expression that selects map items identified by value range (valueBegin inclusive, valueEnd exclusive) If valueBegin is nil, the range is less than valueEnd. If valueEnd is nil, the range is greater than equal to valueBegin.

Expression returns selected data specified by returnType.

func ExpMapGetByValueRelativeRankRange 

func ExpMapGetByValueRelativeRankRange(
	returnType mapReturnType,
	value *Expression,
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByValueRelativeRankRange creates an expression that selects map items nearest to value and greater by relative rank. Expression returns selected data specified by returnType.

Examples for map [{4=2},{9=10},{5=15},{0=17}]:

* (value,rank) = [selected items] * (11,1) = [{0=17}] * (11,-1) = [{9=10},{5=15},{0=17}]

func ExpMapGetByValueRelativeRankRangeCount 

func ExpMapGetByValueRelativeRankRangeCount(
	returnType mapReturnType,
	value *Expression,
	rank *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapGetByValueRelativeRankRangeCount creates an expression that selects map items nearest to value and greater by relative rank with a count limit. Expression returns selected data specified by returnType.

Examples for map [{4=2},{9=10},{5=15},{0=17}]:

* (value,rank,count) = [selected items] * (11,1,1) = [{0=17}] * (11,-1,1) = [{9=10}]

func ExpMapIncrement 

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

ExpMapIncrement creates an expression that increments values by incr for all items identified by key. Valid only for numbers.

func ExpMapPut 

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

ExpMapPut creates an expression that writes key/value item to map bin.

func ExpMapPutItems 

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

ExpMapPutItems creates an expression that writes each map item to map bin.

func ExpMapRemoveByIndex 

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

ExpMapRemoveByIndex creates an expression that removes map item identified by index.

func ExpMapRemoveByIndexRange 

func ExpMapRemoveByIndexRange(
	index *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByIndexRange creates an expression that removes map items starting at specified index to the end of map.

func ExpMapRemoveByIndexRangeCount 

func ExpMapRemoveByIndexRangeCount(
	index *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByIndexRangeCount creates an expression that removes "count" map items starting at specified index.

func ExpMapRemoveByKey 

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

ExpMapRemoveByKey creates an expression that removes map item identified by key.

func ExpMapRemoveByKeyList 

func ExpMapRemoveByKeyList(
	keys *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByKeyList creates an expression that removes map items identified by keys.

func ExpMapRemoveByKeyRange 

func ExpMapRemoveByKeyRange(
	keyBegin *Expression,
	keyEnd *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByKeyRange creates an expression that removes map items identified by key range (keyBegin inclusive, keyEnd exclusive). If keyBegin is nil, the range is less than keyEnd. If keyEnd is nil, the range is greater than equal to keyBegin.

func ExpMapRemoveByKeyRelativeIndexRange 

func ExpMapRemoveByKeyRelativeIndexRange(
	key *Expression,
	index *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByKeyRelativeIndexRange creates an expression that removes map items nearest to key and greater by index.

Examples for map [{0=17},{4=2},{5=15},{9=10}]:

* (value,index) = [removed items] * (5,0) = [{5=15},{9=10}] * (5,1) = [{9=10}] * (5,-1) = [{4=2},{5=15},{9=10}] * (3,2) = [{9=10}] * (3,-2) = [{0=17},{4=2},{5=15},{9=10}]

func ExpMapRemoveByKeyRelativeIndexRangeCount 

func ExpMapRemoveByKeyRelativeIndexRangeCount(
	key *Expression,
	index *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByKeyRelativeIndexRangeCount creates an expression that removes map items nearest to key and greater by index with a count limit.

Examples for map [{0=17},{4=2},{5=15},{9=10}]:

(value,index,count) = [removed items] * (5,0,1) = [{5=15}] * (5,1,2) = [{9=10}] * (5,-1,1) = [{4=2}] * (3,2,1) = [{9=10}] * (3,-2,2) = [{0=17}]

func ExpMapRemoveByRank 

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

ExpMapRemoveByRank creates an expression that removes map item identified by rank.

func ExpMapRemoveByRankRange 

func ExpMapRemoveByRankRange(
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByRankRange creates an expression that removes map items starting at specified rank to the last ranked item.

func ExpMapRemoveByRankRangeCount 

func ExpMapRemoveByRankRangeCount(
	rank *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByRankRangeCount creates an expression that removes "count" map items starting at specified rank.

func ExpMapRemoveByValue 

func ExpMapRemoveByValue(
	value *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByValue creates an expression that removes map items identified by value.

func ExpMapRemoveByValueList 

func ExpMapRemoveByValueList(
	values *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByValueList creates an expression that removes map items identified by values.

func ExpMapRemoveByValueRange 

func ExpMapRemoveByValueRange(
	valueBegin *Expression,
	valueEnd *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByValueRange creates an expression that removes map items identified by value range (valueBegin inclusive, valueEnd exclusive). If valueBegin is nil, the range is less than valueEnd. If valueEnd is nil, the range is greater than equal to valueBegin.

func ExpMapRemoveByValueRelativeRankRange 

func ExpMapRemoveByValueRelativeRankRange(
	value *Expression,
	rank *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByValueRelativeRankRange creates an expression that removes map items nearest to value and greater by relative rank.

Examples for map [{4=2},{9=10},{5=15},{0=17}]:

* (value,rank) = [removed items] * (11,1) = [{0=17}] * (11,-1) = [{9=10},{5=15},{0=17}]

func ExpMapRemoveByValueRelativeRankRangeCount 

func ExpMapRemoveByValueRelativeRankRangeCount(
	value *Expression,
	rank *Expression,
	count *Expression,
	bin *Expression,
	ctx ...*CDTContext,
) *Expression

ExpMapRemoveByValueRelativeRankRangeCount creates an expression that removes map items nearest to value and greater by relative rank with a count limit.

Examples for map [{4=2},{9=10},{5=15},{0=17}]:

* (value,rank,count) = [removed items] * (11,1,1) = [{0=17}] * (11,-1,1) = [{9=10}]

func ExpMapSize 

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

ExpMapSize creates an expression that returns list size.

func ExpMapVal 

func ExpMapVal(val MapValue) *Expression

ExpMapVal creates a Map bin Value

func ExpMax 

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

ExpMax creates expression that returns the maximum value in a variable number of expressions. All arguments must be the same type (integer or float). Requires server version 5.6.0+.

func ExpMemorySize 

func ExpMemorySize() *Expression

ExpMemorySize creates expression that returns record size in memory. If server storage-engine is not memory nor data-in-memory, then zero is returned. This expression usually evaluates quickly because record meta data is cached in memory.

func ExpMin 

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

ExpMin creates expression that returns the minimum value in a variable number of expressions. All arguments must be the same type (integer or float). Requires server version 5.6.0+.

func ExpNilValue 

func ExpNilValue() *Expression

ExpNilValue creates a a Nil Value

func ExpNot 

func ExpNot(exp *Expression) *Expression

ExpNot creates a "not" operator expression.

func ExpNotEq 

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

ExpNotEq creates a not equal (!=) expression

func ExpNumAbs 

func ExpNumAbs(value *Expression) *Expression

ExpNumAbs creates operator that returns absolute value of a number. All arguments must resolve to integer or float. Requires server version 5.6.0+.

func ExpNumAdd 

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

ExpNumAdd creates "add" (+) operator that applies to a variable number of expressions. Return sum of all `FilterExpressions` given. All arguments must resolve to the same type (integer or float). Requires server version 5.6.0+.

func ExpNumCeil 

func ExpNumCeil(num *Expression) *Expression

ExpNumCeil creates expression that rounds a floating point number up to the closest integer value. The return type is float. Requires server version 5.6.0+.

func ExpNumDiv 

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

ExpNumDiv creates "divide" (/) operator that applies to a variable number of expressions. If there is only one `FilterExpressions`, returns the reciprocal for that `FilterExpressions`. Otherwise, return the first `FilterExpressions` divided by the product of the rest. All `FilterExpressions` must resolve to the same type (integer or float). Requires server version 5.6.0+.

func ExpNumFloor 

func ExpNumFloor(num *Expression) *Expression

ExpNumFloor creates expression that rounds a floating point number down to the closest integer value. The return type is float. Requires server version 5.6.0+.

func ExpNumLog 

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

ExpNumLog creates "log" operator for logarithm of "num" with base "base". All arguments must resolve to floats. Requires server version 5.6.0+.

func ExpNumMod 

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

ExpNumMod creates "modulo" (%) operator that determines the remainder of "numerator" divided by "denominator". All arguments must resolve to integers. Requires server version 5.6.0+.

func ExpNumMul 

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

ExpNumMul creates "multiply" (*) operator that applies to a variable number of expressions. Return the product of all `FilterExpressions`. If only one `FilterExpressions` is supplied, return that `FilterExpressions`. All `FilterExpressions` must resolve to the same type (integer or float). Requires server version 5.6.0+.

func ExpNumPow 

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

ExpNumPow creates "power" operator that raises a "base" to the "exponent" power. All arguments must resolve to floats. Requires server version 5.6.0+.

func ExpNumSub 

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

ExpNumSub creates "subtract" (-) operator that applies to a variable number of expressions. If only one `FilterExpressions` is provided, return the negation of that argument. Otherwise, return the sum of the 2nd to Nth `FilterExpressions` subtracted from the 1st `FilterExpressions`. All `FilterExpressions` must resolve to the same type (integer or float). Requires server version 5.6.0+.

func ExpOr 

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

ExpOr creates a "or" (||) operator that applies to a variable number of expressions.

func ExpRegexCompare 

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

ExpRegexCompare creates a function like regular expression string operation.

func ExpSetName 

func ExpSetName() *Expression

ExpSetName creates a function that returns record set name string.

func ExpSinceUpdate 

func ExpSinceUpdate() *Expression

ExpSinceUpdate creates a expression that returns milliseconds since the record was last updated. This expression usually evaluates quickly because record meta data is cached in memory.

func ExpStringBin 

func ExpStringBin(name string) *Expression

ExpStringBin creates a string bin expression.

func ExpStringVal 

func ExpStringVal(val string) *Expression

ExpStringVal creates a String bin value

func ExpTTL 

func ExpTTL() *Expression

ExpTTL creates a function that returns record expiration time (time to live) in integer seconds.

func ExpToFloat 

func ExpToFloat(num *Expression) *Expression

ExpToFloat creates expression that converts a float to an integer. Requires server version 5.6.0+.

func ExpToInt 

func ExpToInt(num *Expression) *Expression

ExpToInt creates expression that converts an integer to a float. Requires server version 5.6.0+.

func ExpUnknown 

func ExpUnknown() *Expression

ExpUnknown creates unknown value. Used to intentionally fail an expression. The failure can be ignored with `ExpWriteFlags` `EVAL_NO_FAIL` or `ExpReadFlags` `EVAL_NO_FAIL`. Requires server version 5.6.0+.

func ExpValueArrayVal 

func ExpValueArrayVal(val ValueArray) *Expression

ExpValueArrayVal creates a List bin Value

func ExpVar 

func ExpVar(name string) *Expression

ExpVar will retrieve expression value from a variable. Requires server version 5.6.0+.

func ExpVoidTime 

func ExpVoidTime() *Expression

ExpVoidTime creates a function that returns record expiration time expressed as 64 bit integer nanoseconds since 1970-01-01 epoch.

type ExpressionArgument 

type ExpressionArgument interface {
	// contains filtered or unexported methods
}

ExpressionArgument is used for passing arguments to filter expressions. The accptable arguments are: Value, ExpressionFilter, []*CDTContext

type FieldType 

type FieldType int

FieldType represents the type of the field in Aerospike Wire Protocol 

const (
	NAMESPACE FieldType = 0
	TABLE     FieldType = 1
	KEY       FieldType = 2

	DIGEST_RIPE FieldType = 4

	DIGEST_RIPE_ARRAY    FieldType = 6
	TRAN_ID              FieldType = 7 // user supplied transaction id, which is simply passed back
	SCAN_OPTIONS         FieldType = 8
	SOCKET_TIMEOUT       FieldType = 9
	RECORDS_PER_SECOND   FieldType = 10
	PID_ARRAY            FieldType = 11
	DIGEST_ARRAY         FieldType = 12
	MAX_RECORDS          FieldType = 13
	BVAL_ARRAY           FieldType = 15
	INDEX_NAME           FieldType = 21
	INDEX_RANGE          FieldType = 22
	INDEX_FILTER         FieldType = 23
	INDEX_LIMIT          FieldType = 24
	INDEX_ORDER_BY       FieldType = 25
	INDEX_TYPE                     = 26
	UDF_PACKAGE_NAME     FieldType = 30
	UDF_FUNCTION         FieldType = 31
	UDF_ARGLIST          FieldType = 32
	UDF_OP               FieldType = 33
	QUERY_BINLIST        FieldType = 40
	BATCH_INDEX          FieldType = 41
	BATCH_INDEX_WITH_SET FieldType = 42
	FILTER_EXP           FieldType = 43
)

FieldType constants used in the Aerospike Wire Protocol.

type Filter 

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

Filter specifies a query filter definition.

func NewContainsFilter 

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

NewContainsFilter creates a contains filter for query on collection index.

func NewContainsRangeFilter 

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

NewContainsRangeFilter creates a contains filter for query on ranges of data in a collection index.

func NewEqualFilter 

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

NewEqualFilter creates a new equality filter instance for query.

func NewGeoRegionsContainingPointFilter 

func NewGeoRegionsContainingPointFilter(binName, point string) *Filter

NewGeoRegionsContainingPointFilter creates a geospatial "containing point" filter for query. Argument must be a valid GeoJSON point.

func NewGeoRegionsContainingPointForCollectionFilter 

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

NewGeoRegionsContainingPointForCollectionFilter creates a geospatial "containing point" filter for query on collection index. Argument must be a valid GeoJSON point.

func NewGeoWithinRadiusFilter 

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

NewGeoWithinRadiusFilter creates a geospatial "within radius" filter for query. Arguments must be valid longitude/latitude/radius (meters) values.

func NewGeoWithinRadiusForCollectionFilter 

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

NewGeoWithinRadiusForCollectionFilter creates a geospatial "within radius" filter for query on collection index. Arguments must be valid longitude/latitude/radius (meters) values.

func NewGeoWithinRegionFilter 

func NewGeoWithinRegionFilter(binName, region string) *Filter

NewGeoWithinRegionFilter creates a geospatial "within region" filter for query. Argument must be a valid GeoJSON region.

func NewGeoWithinRegionForCollectionFilter 

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

NewGeoWithinRegionForCollectionFilter creates a geospatial "within region" filter for query on collection index. Argument must be a valid GeoJSON region.

func NewRangeFilter 

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

NewRangeFilter creates a range filter for query. Range arguments must be int64 values. String ranges are not supported.

func (*Filter) EstimateSize 

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

EstimateSize will estimate the size of the filter for wire protocol

func (*Filter) IndexCollectionType 

func (fltr *Filter) IndexCollectionType() IndexCollectionType

IndexCollectionType returns filter's index type.

type FloatValue 

type FloatValue float64

FloatValue encapsulates an float64 value.

func NewFloatValue 

func NewFloatValue(value float64) FloatValue

NewFloatValue generates a FloatValue instance.

func (FloatValue) EstimateSize 

func (vl FloatValue) EstimateSize() (int, Error)

EstimateSize returns the size of the FloatValue in wire protocol.

func (FloatValue) GetObject 

func (vl FloatValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (FloatValue) GetType 

func (vl FloatValue) GetType() int

GetType returns wire protocol value type.

func (FloatValue) String 

func (vl FloatValue) String() string

String implements Stringer interface.

type GenerationPolicy 

type GenerationPolicy int

GenerationPolicy determines how to handle record writes based on record generation. 

const (
	// NONE means: Do not use record generation to restrict writes.
	NONE GenerationPolicy = iota

	// EXPECT_GEN_EQUAL means: Update/Delete record if expected generation is equal to server generation. Otherwise, fail.
	EXPECT_GEN_EQUAL

	// EXPECT_GEN_GT means: Update/Delete record if expected generation greater than the server generation. Otherwise, fail.
	// This is useful for restore after backup.
	EXPECT_GEN_GT
)

type GeoJSONValue 

type GeoJSONValue string

GeoJSONValue encapsulates a 2D Geo point. Supported by Aerospike 3.6.1 servers and later only.

func NewGeoJSONValue 

func NewGeoJSONValue(value string) GeoJSONValue

NewGeoJSONValue generates a GeoJSONValue instance.

func (GeoJSONValue) EstimateSize 

func (vl GeoJSONValue) EstimateSize() (int, Error)

EstimateSize returns the size of the GeoJSONValue in wire protocol.

func (GeoJSONValue) GetObject 

func (vl GeoJSONValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (GeoJSONValue) GetType 

func (vl GeoJSONValue) GetType() int

GetType returns wire protocol value type.

func (GeoJSONValue) String 

func (vl GeoJSONValue) String() string

String implements Stringer interface.

type HLLPolicy 

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

HLLPolicy determines the HyperLogLog operation policy.

func DefaultHLLPolicy 

func DefaultHLLPolicy() *HLLPolicy

DefaultHLLPolicy uses the default policy when performing HLL operations.

func NewHLLPolicy 

func NewHLLPolicy(flags int) *HLLPolicy

NewHLLPolicy uses specified HLLWriteFlags when performing HLL operations.

type HLLValue 

type HLLValue []byte

HLLValue encapsulates a HyperLogLog value.

func NewHLLValue 

func NewHLLValue(bytes []byte) HLLValue

NewHLLValue generates a ByteValue instance.

func (HLLValue) EstimateSize 

func (vl HLLValue) EstimateSize() (int, Error)

EstimateSize returns the size of the HLLValue in wire protocol.

func (HLLValue) GetObject 

func (vl HLLValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (HLLValue) GetType 

func (vl HLLValue) GetType() int

GetType returns wire protocol value type.

func (HLLValue) String 

func (vl HLLValue) String() string

String implements Stringer interface.

type Host 

type Host struct {

	// Host name or IP address of database server.
	Name string

	//TLSName defines the TLS certificate name used for secure connections.
	TLSName string

	// Port of database server.
	Port int
}

Host name/port of database server.

func NewHost 

func NewHost(name string, port int) *Host

NewHost initializes new host instance.

func (*Host) String 

func (h *Host) String() string

Implements stringer interface

type IndexCollectionType 

type IndexCollectionType int

IndexCollectionType is the secondary index collection type. 

const (

	// ICT_DEFAULT is the Normal scalar index.
	ICT_DEFAULT IndexCollectionType = iota

	// ICT_LIST is Index list elements.
	ICT_LIST

	// ICT_MAPKEYS is Index map keys.
	ICT_MAPKEYS

	// ICT_MAPVALUES is Index map values.
	ICT_MAPVALUES
)

type IndexTask 

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

IndexTask is used to poll for long running create index completion.

func NewIndexTask 

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

NewIndexTask initializes a task with fields needed to query server nodes.

func (*IndexTask) IsDone 

func (tski *IndexTask) IsDone() (bool, Error)

IsDone queries all nodes for task completion status.

func (*IndexTask) OnComplete 

func (tski *IndexTask) OnComplete() chan Error

OnComplete returns a channel that will be closed as soon as the task is finished. If an error is encountered during operation, an error will be sent on the channel.

type IndexType 

type IndexType string

IndexType the type of the secondary index. 

const (
	// NUMERIC specifies an index on numeric values.
	NUMERIC IndexType = "NUMERIC"

	// STRING specifies an index on string values.
	STRING IndexType = "STRING"

	// GEO2DSPHERE specifies 2-dimensional spherical geospatial index.
	GEO2DSPHERE IndexType = "GEO2DSPHERE"
)

type InfinityValue 

type InfinityValue struct{}

InfinityValue is an empty value.

func NewInfinityValue 

func NewInfinityValue() InfinityValue

NewInfinityValue generates a InfinityValue instance.

func (InfinityValue) EstimateSize 

func (vl InfinityValue) EstimateSize() (int, Error)

EstimateSize returns the size of the InfinityValue in wire protocol.

func (InfinityValue) GetObject 

func (vl InfinityValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (InfinityValue) GetType 

func (vl InfinityValue) GetType() int

GetType returns wire protocol value type.

func (InfinityValue) String 

func (vl InfinityValue) String() string

type InfoPolicy 

type InfoPolicy struct {

	// Info command socket timeout.
	// Default is 2 seconds.
	Timeout time.Duration
}

InfoPolicy contains attributes used for info commands.

func NewInfoPolicy 

func NewInfoPolicy() *InfoPolicy

NewInfoPolicy generates a new InfoPolicy with default values.

type IntegerValue 

type IntegerValue int

IntegerValue encapsulates an integer value.

func NewIntegerValue 

func NewIntegerValue(value int) IntegerValue

NewIntegerValue generates an IntegerValue instance.

func (IntegerValue) EstimateSize 

func (vl IntegerValue) EstimateSize() (int, Error)

EstimateSize returns the size of the IntegerValue in wire protocol.

func (IntegerValue) GetObject 

func (vl IntegerValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (IntegerValue) GetType 

func (vl IntegerValue) GetType() int

GetType returns wire protocol value type.

func (IntegerValue) String 

func (vl IntegerValue) String() string

String implements Stringer interface.

type JsonValue 

type JsonValue map[string]interface{}

JsonValue encapsulates a Json map. Supported by Aerospike 3+ servers only.

func NewJsonValue 

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

NewJsonValue generates a JsonValue instance.

func (JsonValue) EstimateSize 

func (vl JsonValue) EstimateSize() (int, Error)

EstimateSize returns the size of the JsonValue in wire protocol.

func (JsonValue) GetObject 

func (vl JsonValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (JsonValue) GetType 

func (vl JsonValue) GetType() int

GetType returns wire protocol value type.

func (JsonValue) String 

func (vl JsonValue) String() string

type Key 

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

Key is the unique record identifier. Records can be identified using a specified namespace, an optional set name, and a user defined key which must be unique within a set. Records can also be identified by namespace/digest which is the combination used on the server.

func (*Key) Digest 

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

Digest returns key digest.

func (*Key) Equals 

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

Equals uses key digests to compare key equality.

func (*Key) Namespace 

func (ky *Key) Namespace() string

Namespace returns key's namespace.

func (*Key) PartitionId 

func (ky *Key) PartitionId() int

PartitionId returns the partition that the key belongs to.

func (*Key) SetDigest 

func (ky *Key) SetDigest(digest []byte) Error

SetDigest sets a custom hash

func (*Key) SetName 

func (ky *Key) SetName() string

SetName returns key's set name.

func (*Key) SetValue 

func (ky *Key) SetValue(val Value) Error

SetValue sets the Key's value and recompute's its digest without allocating new memory. This allows the keys to be reusable.

func (*Key) String 

func (ky *Key) String() string

String implements Stringer interface and returns string representation of key.

func (*Key) Value 

func (ky *Key) Value() Value

Value returns key's value.

type Language 

type Language string

Language specifies User defined function languages. 

const (

	// LUA embedded programming language.
	LUA Language = "LUA"
)

type ListIter 

type ListIter interface {
	PackList(buf BufferEx) (int, error)
	Len() int
}

ListIter allows to define general maps of your own type to be used in the Go client without the use of reflection. function PackList should be exactly Like the following (Do not change, just copy/paste and adapt PackXXX methods): 

func (cs *CustomSlice) PackList(buf aerospike.BufferEx) (int, error) {
	size := 0
	for _, elem := range cs {
		n, err := PackXXX(buf, elem)
		size += n
		if err != nil {
			return size, err
		}
	}
	return size, nil
}
Example (Int) 
package main

import (
	"fmt"
	"log"

	as "github.com/aerospike/aerospike-client-go/v6"
)

/*
myListInt
*/
var _ as.ListIter = myListInt([]int{})

// your custom list
type myListInt []int

func (ml myListInt) PackList(buf as.BufferEx) (int, error) {
	size := 0
	for _, elem := range ml {
		n, err := as.PackInt64(buf, int64(elem))
		size += n
		if err != nil {
			return size, err
		}
	}

	return size, nil
}

func (ml myListInt) Len() int {
	return len(ml)
}

func main() {
	// Setup the client here
	// client, err := as.NewClient("127.0.0.1", 3000)
	// if err != nil {
	// 	log.Fatal(err)
	// }

	var v as.Value = as.NewValue(myListInt([]int{1, 2, 3}))
	key, err := as.NewKey("test", "test", 1)
	if err != nil {
		log.Fatal(err)
	}

	err = client.Put(nil, key, as.BinMap{"myBin": v})
	if err != nil {
		log.Fatal(err)
	}

	rec, err := client.Get(nil, key)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(rec.Bins["myBin"])
}

Output:

[1 2 3]
Example (String) 
package main

import (
	"fmt"
	"log"

	as "github.com/aerospike/aerospike-client-go/v6"
)

/*
myListString
*/
var _ as.ListIter = myListString([]string{})

// your custom list
type myListString []string

func (ml myListString) PackList(buf as.BufferEx) (int, error) {
	size := 0
	for _, elem := range ml {
		n, err := as.PackString(buf, elem)
		size += n
		if err != nil {
			return size, err
		}
	}
	return size, nil
}

func (ml myListString) Len() int {
	return len(ml)
}

func main() {
	// Setup the client here
	// client, err := as.NewClient("127.0.0.1", 3000)
	// if err != nil {
	// 	log.Fatal(err)
	// }

	var v as.Value = as.NewValue(myListString([]string{"a", "b", "c"}))
	key, err := as.NewKey("test", "test", 1)
	if err != nil {
		log.Fatal(err)
	}

	err = client.Put(nil, key, as.BinMap{"myBin": v})
	if err != nil {
		log.Fatal(err)
	}

	rec, err := client.Get(nil, key)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(rec.Bins["myBin"])
}

Output:

[a b c]
Example (Time) 
package main

import (
	"fmt"
	"log"
	"time"

	as "github.com/aerospike/aerospike-client-go/v6"
)

/*
myListTime
*/
var _ as.ListIter = myListTime([]time.Time{})

// your custom list
type myListTime []time.Time

func (ml myListTime) PackList(buf as.BufferEx) (int, error) {
	size := 0
	for _, elem := range ml {
		n, err := as.PackInt64(buf, elem.UnixNano())
		size += n
		if err != nil {
			return size, err
		}
	}
	return size, nil
}

func (ml myListTime) Len() int {
	return len(ml)
}

func main() {
	// Setup the client here
	// client, err := as.NewClient("127.0.0.1", 3000)
	// if err != nil {
	// 	log.Fatal(err)
	// }

	now1 := time.Unix(123123123, 0)
	now2 := time.Unix(123123124, 0)
	now3 := time.Unix(123123125, 0)
	var v as.Value = as.NewValue(myListTime([]time.Time{now1, now2, now3}))
	key, err := as.NewKey("test", "test", 1)
	if err != nil {
		log.Fatal(err)
	}

	err = client.Put(nil, key, as.BinMap{"myBin": v})
	if err != nil {
		log.Fatal(err)
	}

	rec, err := client.Get(nil, key)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(rec.Bins["myBin"])
}

Output:

[123123123000000000 123123124000000000 123123125000000000]

type ListOrderType 

type ListOrderType int

ListOrderType determines the order of returned values in CDT list operations. 

const (
	// ListOrderUnordered signifies that list is not ordered. This is the default.
	ListOrderUnordered ListOrderType = 0

	// ListOrderOrdered signifies that list is Ordered.
	ListOrderOrdered ListOrderType = 1
)

Map storage order.

type ListPolicy 

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

ListPolicy directives when creating a list and writing list items.

func DefaultListPolicy 

func DefaultListPolicy() *ListPolicy

DefaultListPolicy returns the default policy for CDT list operations.

func NewListPolicy 

func NewListPolicy(order ListOrderType, flags int) *ListPolicy

NewListPolicy creates a policy with directives when creating a list and writing list items. Flags are ListWriteFlags. You can specify multiple by `or`ing them together.

type ListReturnType 

type ListReturnType int

ListReturnType determines the returned values in CDT List operations. 

const (
	// ListReturnTypeNone will not return a result.
	ListReturnTypeNone ListReturnType = 0

	// ListReturnTypeIndex will return index offset order.
	// 0 = first key
	// N = Nth key
	// -1 = last key
	ListReturnTypeIndex ListReturnType = 1

	// ListReturnTypeReverseIndex will return reverse index offset order.
	// 0 = last key
	// -1 = first key
	ListReturnTypeReverseIndex ListReturnType = 2

	// ListReturnTypeRank will return value order.
	// 0 = smallest value
	// N = Nth smallest value
	// -1 = largest value
	ListReturnTypeRank ListReturnType = 3

	// ListReturnTypeReverseRank will return reverse value order.
	// 0 = largest value
	// N = Nth largest value
	// -1 = smallest value
	ListReturnTypeReverseRank ListReturnType = 4

	// ListReturnTypeCount will return count of items selected.
	ListReturnTypeCount ListReturnType = 5

	// ListReturnTypeValue will return value for single key read and value list for range read.
	ListReturnTypeValue ListReturnType = 7

	// ListReturnTypeInverted will invert meaning of list command and return values.  For example:
	// ListOperation.getByIndexRange(binName, index, count, ListReturnType.INDEX | ListReturnType.INVERTED)
	// With the INVERTED flag enabled, the items outside of the specified index range will be returned.
	// The meaning of the list command can also be inverted.  For example:
	// ListOperation.removeByIndexRange(binName, index, count, ListReturnType.INDEX | ListReturnType.INVERTED);
	// With the INVERTED flag enabled, the items outside of the specified index range will be removed and returned.
	ListReturnTypeInverted ListReturnType = 0x10000
)

type ListSortFlags 

type ListSortFlags int

ListSortFlags detemines sort flags for CDT lists 

const (
	// ListSortFlagsDefault is the default sort flag for CDT lists, and sort in Ascending order.
	ListSortFlagsDefault ListSortFlags = 0
	// ListSortFlagsDescending will sort the contents of the list in descending order.
	ListSortFlagsDescending ListSortFlags = 1
	// ListSortFlagsDropDuplicates will drop duplicate values in the results of the CDT list operation.
	ListSortFlagsDropDuplicates ListSortFlags = 2
)

type ListValue 

type ListValue []interface{}

ListValue encapsulates any arbitrary array. Supported by Aerospike 3+ servers only.

func NewListValue 

func NewListValue(list []interface{}) ListValue

NewListValue generates a ListValue instance.

func (ListValue) EstimateSize 

func (vl ListValue) EstimateSize() (int, Error)

EstimateSize returns the size of the ListValue in wire protocol.

func (ListValue) GetObject 

func (vl ListValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (ListValue) GetType 

func (vl ListValue) GetType() int

GetType returns wire protocol value type.

func (ListValue) String 

func (vl ListValue) String() string

String implements Stringer interface.

type ListerValue 

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

ListerValue encapsulates any arbitrary array. Supported by Aerospike 3+ servers only.

func NewListerValue 

func NewListerValue(list ListIter) *ListerValue

NewListerValue generates a NewListerValue instance.

func (*ListerValue) EstimateSize 

func (vl *ListerValue) EstimateSize() (int, Error)

EstimateSize returns the size of the ListerValue in wire protocol.

func (*ListerValue) GetObject 

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

GetObject returns original value as an interface{}.

func (*ListerValue) GetType 

func (vl *ListerValue) GetType() int

GetType returns wire protocol value type.

func (*ListerValue) String 

func (vl *ListerValue) String() string

String implements Stringer interface.

type LongValue 

type LongValue int64

LongValue encapsulates an int64 value.

func NewLongValue 

func NewLongValue(value int64) LongValue

NewLongValue generates a LongValue instance.

func (LongValue) EstimateSize 

func (vl LongValue) EstimateSize() (int, Error)

EstimateSize returns the size of the LongValue in wire protocol.

func (LongValue) GetObject 

func (vl LongValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (LongValue) GetType 

func (vl LongValue) GetType() int

GetType returns wire protocol value type.

func (LongValue) String 

func (vl LongValue) String() string

String implements Stringer interface.

type MapIter 

type MapIter interface {
	PackMap(buf BufferEx) (int, error)
	Len() int
}

MapIter allows to define general maps of your own type to be used in the Go client without the use of reflection. function PackMap should be exactly Like the following (Do not change, just copy/paste and adapt PackXXX methods): 

func (cm *CustomMap) PackMap(buf aerospike.BufferEx) (int, error) {
	size := 0
	for k, v := range cm {
		n, err := PackXXX(buf, k)
		size += n
		if err != nil {
			return size, err
		}

		n, err = PackXXX(buf, v)
		size += n
		if err != nil {
			return size, err
		}
	}
	return size, nil
}
Example 
package main

import (
	"fmt"
	"log"
	"time"

	as "github.com/aerospike/aerospike-client-go/v6"
)

/*
myMapStringTime
*/
var _ as.MapIter = myMapStringTime(map[string]time.Time{})

// your custom list
type myMapStringTime map[string]time.Time

func (mm myMapStringTime) PackMap(buf as.BufferEx) (int, error) {
	size := 0
	for key, val := range mm {
		n, err := as.PackString(buf, key)
		size += n
		if err != nil {
			return size, err
		}

		n, err = as.PackInt64(buf, val.UnixNano())
		size += n
		if err != nil {
			return size, err
		}
	}
	return size, nil
}

func (mm myMapStringTime) Len() int {
	return len(mm)
}

func main() {
	// Setup the client here
	// client, err := as.NewClient("127.0.0.1", 3000)
	// if err != nil {
	// 	log.Fatal(err)
	// }

	now := time.Unix(123123123, 0)
	var v as.Value = as.NewValue(myMapStringTime(map[string]time.Time{"now": now}))
	key, err := as.NewKey("test", "test", 1)
	if err != nil {
		log.Fatal(err)
	}

	err = client.Put(nil, key, as.BinMap{"myBin": v})
	if err != nil {
		log.Fatal(err)
	}

	rec, err := client.Get(nil, key)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(rec.Bins["myBin"])
}

Output:

map[now:123123123000000000]

type MapPair 

type MapPair struct{ Key, Value interface{} }

MapPair is used when the client returns sorted maps from the server Since the default map in Go is a hash map, we will use a slice to return the results in server order

type MapPolicy 

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

MapPolicy directives when creating a map and writing map items.

func DefaultMapPolicy 

func DefaultMapPolicy() *MapPolicy

DefaultMapPolicy returns the default map policy

func NewMapPolicy 

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

NewMapPolicy creates a MapPolicy with WriteMode. Use with servers before v4.3.

func NewMapPolicyWithFlags 

func NewMapPolicyWithFlags(order mapOrderType, flags int) *MapPolicy

NewMapPolicyWithFlags creates a MapPolicy with WriteFlags. Use with servers v4.3+. Flags are MapWriteFlags. You can specify multiple flags by 'or'ing them together.

type MapValue 

type MapValue map[interface{}]interface{}

MapValue encapsulates an arbitrary map. Supported by Aerospike 3+ servers only.

func NewMapValue 

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

NewMapValue generates a MapValue instance.

func (MapValue) EstimateSize 

func (vl MapValue) EstimateSize() (int, Error)

EstimateSize returns the size of the MapValue in wire protocol.

func (MapValue) GetObject 

func (vl MapValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (MapValue) GetType 

func (vl MapValue) GetType() int

GetType returns wire protocol value type.

func (MapValue) String 

func (vl MapValue) String() string

type MapperValue 

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

MapperValue encapsulates an arbitrary map which implements a MapIter interface. Supported by Aerospike 3+ servers only.

func NewMapperValue 

func NewMapperValue(vmap MapIter) *MapperValue

NewMapperValue generates a MapperValue instance.

func (*MapperValue) EstimateSize 

func (vl *MapperValue) EstimateSize() (int, Error)

EstimateSize returns the size of the MapperValue in wire protocol.

func (*MapperValue) GetObject 

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

GetObject returns original value as an interface{}.

func (*MapperValue) GetType 

func (vl *MapperValue) GetType() int

GetType returns wire protocol value type.

func (*MapperValue) String 

func (vl *MapperValue) String() string

type MultiPolicy 

type MultiPolicy struct {
	BasePolicy

	// Maximum number of concurrent requests to server nodes at any point in time.
	// If there are 16 nodes in the cluster and maxConcurrentNodes is 8, then queries
	// will be made to 8 nodes in parallel.  When a query completes, a new query will
	// be issued until all 16 nodes have been queried.
	// Default (0) is to issue requests to all server nodes in parallel.
	// 1 will to issue requests to server nodes one by one avoiding parallel queries.
	MaxConcurrentNodes int

	// MaxRecords approximates the number of records to return to the client. This number is divided by the
	// number of nodes involved in the query. The actual number of records returned
	// may be less than MaxRecords if node record counts are small and unbalanced across
	// nodes.
	//
	// This field is supported on server versions >= 4.9.
	//
	// Default: 0 (do not limit record count)
	MaxRecords int64

	// RecordsPerSecond limits returned records per second (rps) rate for each server.
	// Will not apply rps limit if recordsPerSecond is zero (default).
	// Currently only applicable to a query without a defined filter.
	RecordsPerSecond int

	// Number of records to place in queue before blocking.
	// Records received from multiple server nodes will be placed in a queue.
	// A separate goroutine consumes these records in parallel.
	// If the queue is full, the producer goroutines will block until records are consumed.
	RecordQueueSize int //= 50

	// Indicates if bin data is retrieved. If false, only record digests are retrieved.
	IncludeBinData bool //= true;
}

MultiPolicy contains parameters for policy attributes used in query and scan operations.

func NewMultiPolicy 

func NewMultiPolicy() *MultiPolicy

NewMultiPolicy initializes a MultiPolicy instance with default values.

Set MaxRetries for non-aggregation queries with a nil filter on server versions >= 4.9. All other queries are not retried.

The latest servers support retries on individual data partitions. This feature is useful when a cluster is migrating and partition(s) are missed or incomplete on the first query (with nil filter) attempt.

If the first query attempt misses 2 of 4096 partitions, then only those 2 partitions are retried in the next query attempt from the last key digest received for each respective partition. A higher default MaxRetries is used because it's wasteful to invalidate all query results because a single partition was missed.

type Node 

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

Node represents an Aerospike Database Server Node

func (*Node) Close 

func (nd *Node) Close()

Close marks node as inactive and closes all of its pooled connections.

func (*Node) Equals 

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

Equals compares equality of two nodes based on their names.

func (*Node) GetAliases 

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

GetAliases returns node aliases.

func (*Node) GetConnection 

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

GetConnection gets a connection to the node. If no pooled connection is available, a new connection will be created, unless ClientPolicy.MaxQueueSize number of connections are already created. This method will retry to retrieve a connection in case the connection pool is empty, until timeout is reached.

func (*Node) GetHost 

func (nd *Node) GetHost() *Host

GetHost retrieves host for the node.

func (*Node) GetName 

func (nd *Node) GetName() string

GetName returns node name.

func (*Node) InvalidateConnection 

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

InvalidateConnection closes and discards a connection from the pool.

func (*Node) IsActive 

func (nd *Node) IsActive() bool

IsActive Checks if the node is active.

func (*Node) MigrationInProgress 

func (nd *Node) MigrationInProgress() (bool, Error)

MigrationInProgress determines if the node is participating in a data migration

func (*Node) PartitionGeneration 

func (nd *Node) PartitionGeneration() int

PartitionGeneration returns node's Partition Generation

func (*Node) PeersGeneration 

func (nd *Node) PeersGeneration() int

PeersGeneration returns node's Peers Generation

func (*Node) PutConnection 

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

PutConnection puts back a connection to the pool. If connection pool is full, the connection will be closed and discarded.

func (*Node) Rack 

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

Rack returns the rack number for the namespace.

func (*Node) RebalanceGeneration 

func (nd *Node) RebalanceGeneration() int

RebalanceGeneration returns node's Rebalance Generation

func (*Node) Refresh 

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

Refresh requests current status from server node, and updates node with the result.

func (*Node) RequestInfo 

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

RequestInfo gets info values by name from the specified database server node.

func (*Node) RequestStats 

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

RequestStats returns statistics for the specified node as a map

func (*Node) String 

func (nd *Node) String() string

String implements stringer interface

func (*Node) SupportsBatchAny 

func (nd *Node) SupportsBatchAny() bool

SupportsBatchAny returns true if the node supports the feature.

func (*Node) SupportsPartitionQuery 

func (nd *Node) SupportsPartitionQuery() bool

SupportsPartitionQuery returns true if the node supports the feature.

func (*Node) SupportsQueryShow 

func (nd *Node) SupportsQueryShow() bool

SupportsQueryShow returns true if the node supports the feature.

func (*Node) WaitUntillMigrationIsFinished 

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

WaitUntillMigrationIsFinished will block until migration operations are finished.

func (*Node) WarmUp 

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

WarmUp fills the node's connection pool with connections. This is necessary on startup for high traffic programs. If the count is <= 0, the connection queue will be filled. If the count is more than the size of the pool, the pool will be filled. Note: One connection per node is reserved for tend operations and is not used for transactions.

type NullValue 

type NullValue struct{}

NullValue is an empty value.

func NewNullValue 

func NewNullValue() NullValue

NewNullValue generates a NullValue instance.

func (NullValue) EstimateSize 

func (vl NullValue) EstimateSize() (int, Error)

EstimateSize returns the size of the NullValue in wire protocol.

func (NullValue) GetObject 

func (vl NullValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (NullValue) GetType 

func (vl NullValue) GetType() int

GetType returns wire protocol value type.

func (NullValue) String 

func (vl NullValue) String() string

type OpResults 

type OpResults []interface{}

OpResults encapsulates the results of batch read operations

type Operation 

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

Operation contains operation definition. This struct is used in client's operate() method.

func AddOp 

func AddOp(bin *Bin) *Operation

AddOp creates integer add database operation.

func AppendOp 

func AppendOp(bin *Bin) *Operation

AppendOp creates string append database operation.

func BitAddOp 

func BitAddOp(
	policy *BitPolicy,
	binName string,
	bitOffset int,
	bitSize int,
	value int64,
	signed bool,
	action BitOverflowAction,
	ctx ...*CDTContext,
) *Operation

BitAddOp creates bit "add" operation. Server adds value to []byte bin starting at bitOffset for bitSize. BitSize must be <= 64. Signed indicates if bits should be treated as a signed number. If add overflows/underflows, BitOverflowAction is used. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 24
bitSize = 16
value = 128
signed = false
bin result = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b10000101]

func BitAndOp 

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

BitAndOp creates bit "and" operation. Server performs bitwise "and" on value and []byte bin at bitOffset for bitSize. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 23
bitSize = 9
value = [0b00111100, 0b10000000]
bin result = [0b00000001, 0b01000010, 0b00000010, 0b00000000, 0b00000101]

func BitCountOp 

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

BitCountOp creates bit "count" operation. Server returns integer count of set bits from []byte bin starting at bitOffset for bitSize. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 20
bitSize = 4
returns 2

func BitGetIntOp 

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

BitGetIntOp creates bit "get integer" operation. Server returns integer from []byte bin starting at bitOffset for bitSize. Signed indicates if bits should be treated as a signed number. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 8
bitSize = 16
signed = false
returns 16899

func BitGetOp 

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

BitGetOp creates bit "get" operation. Server returns bits from []byte bin starting at bitOffset for bitSize. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 9
bitSize = 5
returns [0b1000000]

func BitInsertOp 

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

BitInsertOp creates byte "insert" operation. Server inserts value bytes into []byte bin at byteOffset. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
byteOffset = 1
value = [0b11111111, 0b11000111]
bin result = [0b00000001, 0b11111111, 0b11000111, 0b01000010, 0b00000011, 0b00000100, 0b00000101]

func BitLScanOp 

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

BitLScanOp creates bit "left scan" operation. Server returns integer bit offset of the first specified value bit in []byte bin starting at bitOffset for bitSize. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 24
bitSize = 8
value = true
returns 5

func BitLShiftOp 

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

BitLShiftOp creates bit "left shift" operation. Server shifts left []byte bin starting at bitOffset for bitSize. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 32
bitSize = 8
shift = 3
bin result = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00101000]

func BitNotOp 

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

BitNotOp creates bit "not" operation. Server negates []byte bin starting at bitOffset for bitSize. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 25
bitSize = 6
bin result = [0b00000001, 0b01000010, 0b00000011, 0b01111010, 0b00000101]

func BitOrOp 

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

BitOrOp creates bit "or" operation. Server performs bitwise "or" on value and []byte bin at bitOffset for bitSize. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 17
bitSize = 6
value = [0b10101000]
bin result = [0b00000001, 0b01000010, 0b01010111, 0b00000100, 0b00000101]

func BitRScanOp 

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

BitRScanOp creates bit "right scan" operation. Server returns integer bit offset of the last specified value bit in []byte bin starting at bitOffset for bitSize. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 32
bitSize = 8
value = true
returns 7

func BitRShiftOp 

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

BitRShiftOp creates bit "right shift" operation. Server shifts right []byte bin starting at bitOffset for bitSize. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 0
bitSize = 9
shift = 1
bin result = [0b00000000, 0b11000010, 0b00000011, 0b00000100, 0b00000101]

func BitRemoveOp 

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

BitRemoveOp creates byte "remove" operation. Server removes bytes from []byte bin at byteOffset for byteSize. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
byteOffset = 2
byteSize = 3
bin result = [0b00000001, 0b01000010]

func BitResizeOp 

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

BitResizeOp creates byte "resize" operation. Server resizes []byte to byteSize according to resizeFlags (See BitResizeFlags). Server does not return a value. Example: 

bin = [0b00000001, 0b01000010]
byteSize = 4
resizeFlags = 0
bin result = [0b00000001, 0b01000010, 0b00000000, 0b00000000]

func BitSetIntOp 

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

BitSetIntOp creates bit "setInt" operation. Server sets value to []byte bin starting at bitOffset for bitSize. Size must be <= 64. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 1
bitSize = 8
value = 127
bin result = [0b00111111, 0b11000010, 0b00000011, 0b0000100, 0b00000101]

func BitSetOp 

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

BitSetOp creates bit "set" operation. Server sets value on []byte bin at bitOffset for bitSize. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 13
bitSize = 3
value = [0b11100000]
bin result = [0b00000001, 0b01000111, 0b00000011, 0b00000100, 0b00000101]

func BitSubtractOp 

func BitSubtractOp(
	policy *BitPolicy,
	binName string,
	bitOffset int,
	bitSize int,
	value int64,
	signed bool,
	action BitOverflowAction,
	ctx ...*CDTContext,
) *Operation

BitSubtractOp creates bit "subtract" operation. Server subtracts value from []byte bin starting at bitOffset for bitSize. BitSize must be <= 64. Signed indicates if bits should be treated as a signed number. If add overflows/underflows, BitOverflowAction is used. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 24
bitSize = 16
value = 128
signed = false
bin result = [0b00000001, 0b01000010, 0b00000011, 0b0000011, 0b10000101]

func BitXorOp 

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

BitXorOp creates bit "exclusive or" operation. Server performs bitwise "xor" on value and []byte bin at bitOffset for bitSize. Server does not return a value. Example: 

bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
bitOffset = 17
bitSize = 6
value = [0b10101100]
bin result = [0b00000001, 0b01000010, 0b01010101, 0b00000100, 0b00000101]

func DeleteOp 

func DeleteOp() *Operation

DeleteOp creates delete record database operation.

func ExpReadOp 

func ExpReadOp(name string, exp *Expression, flags ExpReadFlags) *Operation

ExpReadOp creates an operation with an expression that reads from a record.

func ExpWriteOp 

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

ExpWriteOp creates an operation with an expression that writes to record bin.

func GetBinOp 

func GetBinOp(binName string) *Operation

GetBinOp creates read bin database operation.

func GetHeaderOp 

func GetHeaderOp() *Operation

GetHeaderOp creates read record header database operation.

func GetOp 

func GetOp() *Operation

GetOp creates read all record bins database operation.

func HLLAddOp 

func HLLAddOp(policy *HLLPolicy, binName string, list []Value, indexBitCount, minHashBitCount int) *Operation

HLLAddOp creates HLL add operation with minhash bits. Server adds values to HLL set. If HLL bin does not exist, use indexBitCount and minHashBitCount to create HLL bin. Server returns number of entries that caused HLL to update a register.

policy write policy, use DefaultHLLPolicy for default binName name of bin list list of values to be added indexBitCount number of index bits. Must be between 4 and 16 inclusive. Pass -1 for default. minHashBitCount number of min hash bits. Must be between 4 and 58 inclusive. Pass -1 for default.

func HLLDescribeOp 

func HLLDescribeOp(binName string) *Operation

HLLDescribeOp creates HLL describe operation. Server returns indexBitCount and minHashBitCount used to create HLL bin in a list of longs. The list size is 2.

binName name of bin

func HLLFoldOp 

func HLLFoldOp(binName string, indexBitCount int) *Operation

HLLFoldOp creates HLL fold operation. Servers folds indexBitCount to the specified value. This can only be applied when minHashBitCount on the HLL bin is 0. Server does not return a value.

binName name of bin indexBitCount number of index bits. Must be between 4 and 16 inclusive.

func HLLGetCountOp 

func HLLGetCountOp(binName string) *Operation

HLLGetCountOp creates HLL getCount operation. Server returns estimated number of elements in the HLL bin.

binName name of bin

func HLLGetIntersectCountOp 

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

HLLGetIntersectCountOp creates HLL getIntersectCount operation. Server returns estimated number of elements that would be contained by the intersection of these HLL objects.

binName name of bin list list of HLL objects

func HLLGetSimilarityOp 

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

HLLGetSimilarityOp creates HLL getSimilarity operation. Server returns estimated similarity of these HLL objects. Return type is a double.

binName name of bin list list of HLL objects

func HLLGetUnionCountOp 

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

HLLGetUnionCountOp creates HLL getUnionCount operation. Server returns estimated number of elements that would be contained by the union of these HLL objects.

binName name of bin list list of HLL objects

func HLLGetUnionOp 

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

HLLGetUnionOp creates HLL getUnion operation. Server returns an HLL object that is the union of all specified HLL objects in the list with the HLL bin.

binName name of bin list list of HLL objects

func HLLInitOp 

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

HLLInitOp creates HLL init operation with minhash bits. Server creates a new HLL or resets an existing HLL. Server does not return a value.

policy write policy, use DefaultHLLPolicy for default binName name of bin indexBitCount number of index bits. Must be between 4 and 16 inclusive. Pass -1 for default. minHashBitCount number of min hash bits. Must be between 4 and 58 inclusive. Pass -1 for default.

func HLLRefreshCountOp 

func HLLRefreshCountOp(binName string) *Operation

HLLRefreshCountOp creates HLL refresh operation. Server updates the cached count (if stale) and returns the count.

binName name of bin

func HLLSetUnionOp 

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

HLLSetUnionOp creates HLL set union operation. Server sets union of specified HLL objects with HLL bin. Server does not return a value.

policy write policy, use DefaultHLLPolicy for default binName name of bin list list of HLL objects

func ListAppendOp 

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

ListAppendOp creates a list append operation. Server appends values to end of list bin. Server returns list size on bin name. It will panic is no values have been passed.

func ListAppendWithPolicyContextOp 

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

ListAppendWithPolicyContextOp creates a list append operation. Server appends values to end of list bin. Server returns list size on bin name. It will panic is no values have been passed.

func ListAppendWithPolicyOp 

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

ListAppendWithPolicyOp creates a list append operation. Server appends values to end of list bin. Server returns list size on bin name. It will panic is no values have been passed.

func ListClearOp 

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

ListClearOp creates a list clear operation. Server removes all items in list bin. Server does not return a result by default.

func ListCreateOp 

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

ListCreateOp creates list create operation. Server creates list at given context level. The context is allowed to be beyond list boundaries only if pad is set to true. In that case, nil list entries will be inserted to satisfy the context position.

func ListGetByIndexOp 

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

ListGetByIndexOp creates list get by index operation. Server selects list item identified by index and returns selected data specified by returnType

func ListGetByIndexRangeCountOp 

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

ListGetByIndexRangeCountOp creates list get by index range operation. Server selects "count" list items starting at specified index and returns selected data specified by returnType.

func ListGetByIndexRangeOp 

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

ListGetByIndexRangeOp creates list get by index range operation. Server selects list items starting at specified index to the end of list and returns selected data specified by returnType.

func ListGetByRankOp 

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

ListGetByRankOp creates a list get by rank operation. Server selects list item identified by rank and returns selected data specified by returnType.

func ListGetByRankRangeCountOp 

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

ListGetByRankRangeCountOp creates a list get by rank range operation. Server selects "count" list items starting at specified rank and returns selected data specified by returnType.

func ListGetByRankRangeOp 

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

ListGetByRankRangeOp creates a list get by rank range operation. Server selects list items starting at specified rank to the last ranked item and returns selected data specified by returnType.

func ListGetByValueListOp 

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

ListGetByValueListOp creates list get by value list operation. Server selects list items identified by values and returns selected data specified by returnType.

func ListGetByValueOp 

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

ListGetByValueOp creates a list get by value operation. Server selects list items identified by value and returns selected data specified by returnType.

func ListGetByValueRangeOp 

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

ListGetByValueRangeOp creates a list get by value range operation. Server selects list items identified by value range (valueBegin inclusive, valueEnd exclusive) If valueBegin is nil, the range is less than valueEnd. If valueEnd is nil, the range is greater than equal to valueBegin. Server returns selected data specified by returnType.

func ListGetByValueRelativeRankRangeCountOp 

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

ListGetByValueRelativeRankRangeCountOp creates a list get by value relative to rank range operation. Server selects list items nearest to value and greater by relative rank with a count limit. Server returns selected data specified by returnType.

Examples for ordered list [0,4,5,9,11,15]: 

(value,rank,count) = [selected items]
(5,0,2) = [5,9]
(5,1,1) = [9]
(5,-1,2) = [4,5]
(3,0,1) = [4]
(3,3,7) = [11,15]
(3,-3,2) = []

func ListGetByValueRelativeRankRangeOp 

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

ListGetByValueRelativeRankRangeOp creates a list get by value relative to rank range operation. Server selects list items nearest to value and greater by relative rank. Server returns selected data specified by returnType.

Examples for ordered list [0,4,5,9,11,15]: 

(value,rank) = [selected items]
(5,0) = [5,9,11,15]
(5,1) = [9,11,15]
(5,-1) = [4,5,9,11,15]
(3,0) = [4,5,9,11,15]
(3,3) = [11,15]
(3,-3) = [0,4,5,9,11,15]

func ListGetOp 

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

ListGetOp creates a list get operation. Server returns item at specified index in list bin.

func ListGetRangeFromOp 

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

ListGetRangeFromOp creates a list get range operation. Server returns items starting at specified index to the end of list.

func ListGetRangeOp 

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

ListGetRangeOp creates a list get range operation. Server returns "count" items starting at specified index in list bin.

func ListIncrementByOneOp 

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

ListIncrementByOneOp creates list increment operation with policy. Server increments list[index] by 1. Server returns list[index] after incrementing.

func ListIncrementByOneWithPolicyOp 

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

ListIncrementByOneWithPolicyOp creates list increment operation with policy. Server increments list[index] by 1. Server returns list[index] after incrementing.

func ListIncrementOp 

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

ListIncrementOp creates a list increment operation. Server increments list[index] by value. Value should be integer(IntegerValue, LongValue) or float(FloatValue). Server returns list[index] after incrementing.

func ListIncrementWithPolicyOp 

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

ListIncrementWithPolicyOp creates a list increment operation. Server increments list[index] by value. Server returns list[index] after incrementing.

func ListInsertOp 

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

ListInsertOp creates a list insert operation. Server inserts value to specified index of list bin. Server returns list size on bin name. It will panic is no values have been passed.

func ListInsertWithPolicyContextOp 

func ListInsertWithPolicyContextOp(policy *ListPolicy, binName string, index int, ctx []*CDTContext, values ...interface{}) *Operation

ListInsertWithPolicyContextOp creates a list insert operation. Server inserts value to specified index of list bin. Server returns list size on bin name. It will panic is no values have been passed.

func ListInsertWithPolicyOp 

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

ListInsertWithPolicyOp creates a list insert operation. Server inserts value to specified index of list bin. Server returns list size on bin name. It will panic is no values have been passed.

func ListPopOp 

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

ListPopOp creates list pop operation. Server returns item at specified index and removes item from list bin.

func ListPopRangeFromOp 

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

ListPopRangeFromOp creates a list pop range operation. Server returns items starting at specified index to the end of list and removes items from list bin.

func ListPopRangeOp 

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

ListPopRangeOp creates a list pop range operation. Server returns items starting at specified index and removes items from list bin.

func ListRemoveByIndexOp 

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

ListRemoveByIndexOp creates a list remove operation. Server removes list item identified by index and returns removed data specified by returnType.

func ListRemoveByIndexRangeCountOp 

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

ListRemoveByIndexRangeCountOp creates a list remove operation. Server removes "count" list items starting at specified index and returns removed data specified by returnType.

func ListRemoveByIndexRangeOp 

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

ListRemoveByIndexRangeOp creates a list remove operation. Server removes list items starting at specified index to the end of list and returns removed data specified by returnType.

func ListRemoveByRankOp 

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

ListRemoveByRankOp creates a list remove operation. Server removes list item identified by rank and returns removed data specified by returnType.

func ListRemoveByRankRangeCountOp 

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

ListRemoveByRankRangeCountOp creates a list remove operation. Server removes "count" list items starting at specified rank and returns removed data specified by returnType.

func ListRemoveByRankRangeOp 

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

ListRemoveByRankRangeOp creates a list remove operation. Server removes list items starting at specified rank to the last ranked item and returns removed data specified by returnType.

func ListRemoveByValueListOp 

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

ListRemoveByValueListOp creates list remove by value operation. Server removes list items identified by value and returns removed data specified by returnType.

func ListRemoveByValueOp 

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

ListRemoveByValueOp creates list remove by value operation. Server removes the item identified by value and returns removed data specified by returnType.

func ListRemoveByValueRangeOp 

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

ListRemoveByValueRangeOp creates a list remove operation. Server removes list items identified by value range (valueBegin inclusive, valueEnd exclusive). If valueBegin is nil, the range is less than valueEnd. If valueEnd is nil, the range is greater than equal to valueBegin. Server returns removed data specified by returnType

func ListRemoveByValueRelativeRankRangeCountOp 

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

ListRemoveByValueRelativeRankRangeCountOp creates a list remove by value relative to rank range operation. Server removes list items nearest to value and greater by relative rank with a count limit. Server returns removed data specified by returnType. Examples for ordered list [0,4,5,9,11,15]: 

(value,rank,count) = [removed items]
(5,0,2) = [5,9]
(5,1,1) = [9]
(5,-1,2) = [4,5]
(3,0,1) = [4]
(3,3,7) = [11,15]
(3,-3,2) = []

func ListRemoveByValueRelativeRankRangeOp 

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

ListRemoveByValueRelativeRankRangeOp creates a list remove by value relative to rank range operation. Server removes list items nearest to value and greater by relative rank. Server returns removed data specified by returnType.

Examples for ordered list [0,4,5,9,11,15]: 

(value,rank) = [removed items]
(5,0) = [5,9,11,15]
(5,1) = [9,11,15]
(5,-1) = [4,5,9,11,15]
(3,0) = [4,5,9,11,15]
(3,3) = [11,15]
(3,-3) = [0,4,5,9,11,15]

func ListRemoveOp 

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

ListRemoveOp creates a list remove operation. Server removes item at specified index from list bin. Server returns number of items removed.

func ListRemoveRangeFromOp 

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

ListRemoveRangeFromOp creates a list remove range operation. Server removes all items starting at specified index to the end of list. Server returns number of items removed.

func ListRemoveRangeOp 

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

ListRemoveRangeOp creates a list remove range operation. Server removes "count" items starting at specified index from list bin. Server returns number of items removed.

func ListSetOp 

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

ListSetOp creates a list set operation. Server sets item value at specified index in list bin. Server does not return a result by default.

func ListSetOrderOp 

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

ListSetOrderOp creates a set list order operation. Server sets list order. Server returns nil.

func ListSizeOp 

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

ListSizeOp creates a list size operation. Server returns size of list on bin name.

func ListSortOp 

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

ListSortOp creates list sort operation. Server sorts list according to sortFlags. Server does not return a result by default.

func ListTrimOp 

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

ListTrimOp creates a list trim operation. Server removes items in list bin that do not fall into range specified by index and count range. If the range is out of bounds, then all items will be removed. Server returns number of elemts that were removed.

func MapClearOp 

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

MapClearOp creates map clear operation. Server removes all items in map. Server returns nil.

func MapCreateOp 

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

MapCreateOp creates a map create operation. Server creates map at given context level.

func MapDecrementOp 

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

MapDecrementOp creates map decrement operation. Server decrements values by decr for all items identified by key and returns final result. Valid only for numbers.

The required map policy dictates the type of map to create when it does not exist. The map policy also specifies the mode used when writing items to the map.

func MapGetByIndexOp 

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

MapGetByIndexOp creates map get by index operation. Server selects map item identified by index and returns selected data specified by returnType.

func MapGetByIndexRangeCountOp 

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

MapGetByIndexRangeCountOp creates map get by index range operation. Server selects "count" map items starting at specified index and returns selected data specified by returnType.

func MapGetByIndexRangeOp 

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

MapGetByIndexRangeOp creates map get by index range operation. Server selects map items starting at specified index to the end of map and returns selected data specified by returnType.

func MapGetByKeyListOp 

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

MapGetByKeyListOp creates a map get by key list operation. Server selects map items identified by keys and returns selected data specified by returnType.

func MapGetByKeyOp 

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

MapGetByKeyOp creates map get by key operation. Server selects map item identified by key and returns selected data specified by returnType.

func MapGetByKeyRangeOp 

func MapGetByKeyRangeOp(binName string, keyBegin interface{}, keyEnd interface{}, returnType mapReturnType, ctx ...*CDTContext) *Operation

MapGetByKeyRangeOp creates map get by key range operation. Server selects map items identified by key range (keyBegin inclusive, keyEnd exclusive). If keyBegin is nil, the range is less than keyEnd. If keyEnd is nil, the range is greater than equal to keyBegin.

Server returns selected data specified by returnType.

func MapGetByKeyRelativeIndexRangeCountOp 

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

MapGetByKeyRelativeIndexRangeCountOp creates a map get by key relative to index range operation. Server selects map items nearest to key and greater by index with a count limit. Server returns selected data specified by returnType (See MapReturnType).

Examples for ordered map [{0=17},{4=2},{5=15},{9=10}]: 

(value,index,count) = [selected items]
(5,0,1) = [{5=15}]
(5,1,2) = [{9=10}]
(5,-1,1) = [{4=2}]
(3,2,1) = [{9=10}]
(3,-2,2) = [{0=17}]

func MapGetByKeyRelativeIndexRangeOp 

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

MapGetByKeyRelativeIndexRangeOp creates a map get by key relative to index range operation. Server selects map items nearest to key and greater by index. Server returns selected data specified by returnType.

Examples for ordered map [{0=17},{4=2},{5=15},{9=10}]: 

(value,index) = [selected items]
(5,0) = [{5=15},{9=10}]
(5,1) = [{9=10}]
(5,-1) = [{4=2},{5=15},{9=10}]
(3,2) = [{9=10}]
(3,-2) = [{0=17},{4=2},{5=15},{9=10}]

func MapGetByRankOp 

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

MapGetByRankOp creates map get by rank operation. Server selects map item identified by rank and returns selected data specified by returnType.

func MapGetByRankRangeCountOp 

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

MapGetByRankRangeCountOp creates map get by rank range operation. Server selects "count" map items starting at specified rank and returns selected data specified by returnType.

func MapGetByRankRangeOp 

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

MapGetByRankRangeOp creates map get by rank range operation. Server selects map items starting at specified rank to the last ranked item and returns selected data specified by returnType.

func MapGetByValueListOp 

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

MapGetByValueListOp creates map get by value list operation. Server selects map items identified by values and returns selected data specified by returnType.

func MapGetByValueOp 

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

MapGetByValueOp creates map get by value operation. Server selects map items identified by value and returns selected data specified by returnType.

func MapGetByValueRangeOp 

func MapGetByValueRangeOp(binName string, valueBegin interface{}, valueEnd interface{}, returnType mapReturnType, ctx ...*CDTContext) *Operation

MapGetByValueRangeOp creates map get by value range operation. Server selects map items identified by value range (valueBegin inclusive, valueEnd exclusive) If valueBegin is nil, the range is less than valueEnd. If valueEnd is nil, the range is greater than equal to valueBegin.

Server returns selected data specified by returnType.

func MapGetByValueRelativeRankRangeCountOp 

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

MapGetByValueRelativeRankRangeCountOp creates a map get by value relative to rank range operation. Server selects map items nearest to value and greater by relative rank with a count limit. Server returns selected data specified by returnType.

Examples for map [{4=2},{9=10},{5=15},{0=17}]: 

(value,rank,count) = [selected items]
(11,1,1) = [{0=17}]
(11,-1,1) = [{9=10}]

func MapGetByValueRelativeRankRangeOp 

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

MapGetByValueRelativeRankRangeOp creates a map get by value relative to rank range operation. Server selects map items nearest to value and greater by relative rank. Server returns selected data specified by returnType.

Examples for map [{4=2},{9=10},{5=15},{0=17}]: 

(value,rank) = [selected items]
(11,1) = [{0=17}]
(11,-1) = [{9=10},{5=15},{0=17}]

func MapIncrementOp 

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

MapIncrementOp creates map increment operation. Server increments values by incr for all items identified by key and returns final result. Valid only for numbers.

The required map policy dictates the type of map to create when it does not exist. The map policy also specifies the mode used when writing items to the map.

func MapPutItemsOp 

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

MapPutItemsOp creates map put items operation Server writes each map item to map bin and returns map size.

The required map policy dictates the type of map to create when it does not exist. The map policy also specifies the mode used when writing items to the map.

func MapPutOp 

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

MapPutOp creates map put operation. Server writes key/value item to map bin and returns map size.

The required map policy dictates the type of map to create when it does not exist. The map policy also specifies the mode used when writing items to the map.

func MapRemoveByIndexOp 

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

MapRemoveByIndexOp creates map remove operation. Server removes map item identified by index and returns removed data specified by returnType.

func MapRemoveByIndexRangeCountOp 

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

MapRemoveByIndexRangeCountOp creates map remove operation. Server removes "count" map items starting at specified index and returns removed data specified by returnType.

func MapRemoveByIndexRangeOp 

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

MapRemoveByIndexRangeOp creates map remove operation. Server removes map items starting at specified index to the end of map and returns removed data specified by returnType.

func MapRemoveByKeyListOp 

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

MapRemoveByKeyListOp creates map remove operation. Server removes map items identified by keys and returns removed data specified by returnType.

func MapRemoveByKeyOp 

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

MapRemoveByKeyOp creates map remove operation. Server removes map item identified by key and returns removed data specified by returnType.

func MapRemoveByKeyRangeOp 

func MapRemoveByKeyRangeOp(binName string, keyBegin interface{}, keyEnd interface{}, returnType mapReturnType, ctx ...*CDTContext) *Operation

MapRemoveByKeyRangeOp creates map remove operation. Server removes map items identified by key range (keyBegin inclusive, keyEnd exclusive). If keyBegin is nil, the range is less than keyEnd. If keyEnd is nil, the range is greater than equal to keyBegin.

Server returns removed data specified by returnType.

func MapRemoveByKeyRelativeIndexRangeCountOp 

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

MapRemoveByKeyRelativeIndexRangeCountOp creates map remove by key relative to index range operation. Server removes map items nearest to key and greater by index with a count limit. Server returns removed data specified by returnType.

Examples for map [{0=17},{4=2},{5=15},{9=10}]: 

(value,index,count) = [removed items]
(5,0,1) = [{5=15}]
(5,1,2) = [{9=10}]
(5,-1,1) = [{4=2}]
(3,2,1) = [{9=10}]
(3,-2,2) = [{0=17}]

func MapRemoveByKeyRelativeIndexRangeOp 

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

MapRemoveByKeyRelativeIndexRangeOp creates a map remove by key relative to index range operation. Server removes map items nearest to key and greater by index. Server returns removed data specified by returnType.

Examples for map [{0=17},{4=2},{5=15},{9=10}]: 

(value,index) = [removed items]
(5,0) = [{5=15},{9=10}]
(5,1) = [{9=10}]
(5,-1) = [{4=2},{5=15},{9=10}]
(3,2) = [{9=10}]
(3,-2) = [{0=17},{4=2},{5=15},{9=10}]

func MapRemoveByRankOp 

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

MapRemoveByRankOp creates map remove operation. Server removes map item identified by rank and returns removed data specified by returnType.

func MapRemoveByRankRangeCountOp 

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

MapRemoveByRankRangeCountOp creates map remove operation. Server removes "count" map items starting at specified rank and returns removed data specified by returnType.

func MapRemoveByRankRangeOp 

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

MapRemoveByRankRangeOp creates map remove operation. Server removes map items starting at specified rank to the last ranked item and returns removed data specified by returnType.

func MapRemoveByValueListOp 

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

MapRemoveByValueListOp creates map remove operation. Server removes map items identified by values and returns removed data specified by returnType.

func MapRemoveByValueOp 

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

MapRemoveByValueOp creates map remove operation. Server removes map items identified by value and returns removed data specified by returnType.

func MapRemoveByValueRangeOp 

func MapRemoveByValueRangeOp(binName string, valueBegin interface{}, valueEnd interface{}, returnType mapReturnType, ctx ...*CDTContext) *Operation

MapRemoveByValueRangeOp creates map remove operation. Server removes map items identified by value range (valueBegin inclusive, valueEnd exclusive). If valueBegin is nil, the range is less than valueEnd. If valueEnd is nil, the range is greater than equal to valueBegin.

Server returns removed data specified by returnType.

func MapRemoveByValueRelativeRankRangeCountOp 

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

MapRemoveByValueRelativeRankRangeCountOp creates a map remove by value relative to rank range operation. Server removes map items nearest to value and greater by relative rank with a count limit. Server returns removed data specified by returnType (See MapReturnType).

Examples for map [{4=2},{9=10},{5=15},{0=17}]: 

(value,rank,count) = [removed items]
(11,1,1) = [{0=17}]
(11,-1,1) = [{9=10}]

func MapRemoveByValueRelativeRankRangeOp 

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

MapRemoveByValueRelativeRankRangeOp creates a map remove by value relative to rank range operation. Server removes map items nearest to value and greater by relative rank. Server returns removed data specified by returnType.

Examples for map [{4=2},{9=10},{5=15},{0=17}]: 

(value,rank) = [removed items]
(11,1) = [{0=17}]
(11,-1) = [{9=10},{5=15},{0=17}]

func MapSetPolicyOp 

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

MapSetPolicyOp creates set map policy operation. Server sets map policy attributes. Server returns nil.

The required map policy attributes can be changed after the map is created.

func MapSizeOp 

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

MapSizeOp creates map size operation. Server returns size of map.

func PrependOp 

func PrependOp(bin *Bin) *Operation

PrependOp creates string prepend database operation.

func PutOp 

func PutOp(bin *Bin) *Operation

PutOp creates set database operation.

func TouchOp 

func TouchOp() *Operation

TouchOp creates touch record database operation.

type OperationType 

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

OperationType determines operation type

type Partition 

type Partition struct {
	// Namespace of the partition
	Namespace string
	// PartitionId of the partition
	PartitionId int
	// contains filtered or unexported fields
}

Partition encapsulates partition information.

func NewPartition 

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

NewPartition returns a partition representation

func (*Partition) Equals 

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

Equals checks equality of two partitions.

func (*Partition) GetNodeRead 

func (ptn *Partition) GetNodeRead(cluster *Cluster) (*Node, Error)

GetNodeRead returns a node for read operations

func (*Partition) GetNodeWrite 

func (ptn *Partition) GetNodeWrite(cluster *Cluster) (*Node, Error)

GetNodeWrite returns a node for write operations

func (*Partition) PrepareRetryRead 

func (ptn *Partition) PrepareRetryRead(isClientTimeout bool)

PrepareRetryRead increases sequence number before read retries

func (*Partition) PrepareRetryWrite 

func (ptn *Partition) PrepareRetryWrite(isClientTimeout bool)

PrepareRetryWrite increases sequence number before write retries

func (*Partition) String 

func (ptn *Partition) String() string

String implements the Stringer interface.

type PartitionFilter 

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

PartitionFilter is used in scan/queries.

func NewPartitionFilterAll 

func NewPartitionFilterAll() *PartitionFilter

NewPartitionFilterAll creates a partition filter that reads all the partitions.

func NewPartitionFilterById 

func NewPartitionFilterById(partitionId int) *PartitionFilter

NewPartitionFilterById creates a partition filter by partition id. Partition id is between 0 - 4095

func NewPartitionFilterByKey 

func NewPartitionFilterByKey(key *Key) *PartitionFilter

NewPartitionFilterByKey creates a partition filter that will return records after key's digest in the partition containing the digest. Note that digest order is not the same as userKey order. This method only works for scan or query with nil filter.

func NewPartitionFilterByRange 

func NewPartitionFilterByRange(begin, count int) *PartitionFilter

NewPartitionFilterByRange creates a partition filter by partition range. begin partition id is between 0 - 4095 count is the number of partitions, in the range of 1 - 4096 inclusive.

func (*PartitionFilter) IsDone 

func (pf *PartitionFilter) IsDone() bool

IsDone returns - if using ScanPolicy.MaxRecords or QueryPolicy,MaxRecords - if the previous paginated scans with this partition filter instance return all records?

type Partitions 

type Partitions struct {
	Replicas [][]*Node
	SCMode   bool
	// contains filtered or unexported fields
}

Partitions represents a list of partitions

type Policy 

type Policy interface {
	// Retrieves BasePolicy
	GetBasePolicy() *BasePolicy
	// contains filtered or unexported methods
}

Policy Interface

type Privilege 

type Privilege struct {
	// Role
	Code privilegeCode

	// Namespace determines namespace scope. Apply permission to this namespace only.
	// If namespace is zero value, the privilege applies to all namespaces.
	Namespace string

	// Set name scope. Apply permission to this set within namespace only.
	// If set is zero value, the privilege applies to all sets within namespace.
	SetName string
}

Privilege determines user access granularity.

type QueryPolicy 

type QueryPolicy struct {
	MultiPolicy

	// ShortQuery detemines wether query expected to return less than 100 records.
	// If true, the server will optimize the query for a small record set.
	// This field is ignored for aggregation queries, background queries
	// and server versions 6.0+.
	//
	// Default: false
	ShortQuery bool
}

QueryPolicy encapsulates parameters for policy attributes used in query operations.

func NewQueryPolicy 

func NewQueryPolicy() *QueryPolicy

NewQueryPolicy generates a new QueryPolicy instance with default values. Set MaxRetries for non-aggregation queries with a nil filter on server versions >= 4.9. All other queries are not retried.

The latest servers support retries on individual data partitions. This feature is useful when a cluster is migrating and partition(s) are missed or incomplete on the first query (with nil filter) attempt.

If the first query attempt misses 2 of 4096 partitions, then only those 2 partitions are retried in the next query attempt from the last key digest received for each respective partition. A higher default MaxRetries is used because it's wasteful to invalidate all query results because a single partition was missed.

type ReadModeAP 

type ReadModeAP int

ReadModeAP is the read policy in AP (availability) mode namespaces. It indicates how duplicates should be consulted in a read operation. Only makes a difference during migrations and only applicable in AP mode. 

const (
	// ReadModeAPOne indicates that a single node should be involved in the read operation.
	ReadModeAPOne ReadModeAP = iota

	// ReadModeAPAll indicates that all duplicates should be consulted in
	// the read operation.
	ReadModeAPAll
)

type ReadModeSC 

type ReadModeSC int

ReadModeSC is the read policy in SC (strong consistency) mode namespaces. Determines SC read consistency options. 

const (
	// ReadModeSCSession ensures this client will only see an increasing sequence of record versions.
	// Server only reads from master.  This is the default.
	ReadModeSCSession ReadModeSC = iota

	// ReadModeSCLinearize ensures ALL clients will only see an increasing sequence of record versions.
	// Server only reads from master.
	ReadModeSCLinearize

	// ReadModeSCAllowReplica indicates that the server may read from master or any full (non-migrating) replica.
	// Increasing sequence of record versions is not guaranteed.
	ReadModeSCAllowReplica

	// ReadModeSCAllowUnavailable indicates that the server may read from master or any full (non-migrating) replica or from unavailable
	// partitions.  Increasing sequence of record versions is not guaranteed.
	ReadModeSCAllowUnavailable
)

type Record 

type Record struct {
	// Key is the record's key.
	// Might be empty, or may only consist of digest value.
	Key *Key

	// Node from which the Record is originating from.
	Node *Node

	// Bins is the map of requested name/value bins.
	Bins BinMap

	// Generation shows record modification count.
	Generation uint32

	// Expiration is TTL (Time-To-Live).
	// Number of seconds until record expires.
	Expiration uint32
}

Record is the container struct for database records. Records are equivalent to rows.

func (*Record) String 

func (rc *Record) String() string

String implements the Stringer interface. Returns string representation of record.

type RecordExistsAction 

type RecordExistsAction int

RecordExistsAction determines how to handle writes when the record already exists. 

const (

	// UPDATE means: Create or update record.
	// Merge write command bins with existing bins.
	UPDATE RecordExistsAction = iota

	// UPDATE_ONLY means: Update record only. Fail if record does not exist.
	// Merge write command bins with existing bins.
	UPDATE_ONLY

	// REPLACE means: Create or replace record.
	// Delete existing bins not referenced by write command bins.
	// Supported by Aerospike 2 server versions >= 2.7.5 and
	// Aerospike 3 server versions >= 3.1.6 and later.
	REPLACE

	// REPLACE_ONLY means: Replace record only. Fail if record does not exist.
	// Delete existing bins not referenced by write command bins.
	// Supported by Aerospike 2 server versions >= 2.7.5 and
	// Aerospike 3 server versions >= 3.1.6 and later.
	REPLACE_ONLY

	// CREATE_ONLY means: Create only. Fail if record exists.
	CREATE_ONLY
)

type Recordset 

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

Recordset encapsulates the result of Scan and Query commands.

func (*Recordset) Close 

func (rcs *Recordset) Close() Error

Close all streams from different nodes. A successful close return nil, subsequent calls to the method will return ErrRecordsetClosed.err().

func (*Recordset) Errors 

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

Errors returns a read-only Error channel for the objectset. It will panic for recordsets returned for non-reflection APIs.

func (*Recordset) IsActive 

func (rcs *Recordset) IsActive() bool

IsActive returns true if the operation hasn't been finished or cancelled.

func (*Recordset) Results 

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

Results returns a new receive-only channel with the results of the Scan/Query. This is a more idiomatic approach to the iterator pattern in getting the results back from the recordset, and doesn't require the user to write the ugly select in their code. Result contains a Record and an error reference.

Example: 

recordset, err := client.ScanAll(nil, namespace, set)
handleError(err)
for res := range recordset.Results() {
  if res.Err != nil {
    // handle error here
  } else {
    // process record here
    fmt.Println(res.Record.Bins)
  }
}

func (*Recordset) TaskId 

func (os *Recordset) TaskId() uint64

TaskId returns the transactionId/jobId sent to the server for this recordset.

type RegisterTask 

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

RegisterTask is used to poll for UDF registration completion.

func NewRegisterTask 

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

NewRegisterTask initializes a RegisterTask with fields needed to query server nodes.

func (*RegisterTask) IsDone 

func (tskr *RegisterTask) IsDone() (bool, Error)

IsDone will query all nodes for task completion status.

func (*RegisterTask) OnComplete 

func (tskr *RegisterTask) OnComplete() chan Error

OnComplete returns a channel that will be closed as soon as the task is finished. If an error is encountered during operation, an error will be sent on the channel.

type RemoveTask 

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

RemoveTask is used to poll for UDF registration completion.

func NewRemoveTask 

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

NewRemoveTask initializes a RemoveTask with fields needed to query server nodes.

func (*RemoveTask) IsDone 

func (tskr *RemoveTask) IsDone() (bool, Error)

IsDone will query all nodes for task completion status.

func (*RemoveTask) OnComplete 

func (tskr *RemoveTask) OnComplete() chan Error

OnComplete returns a channel that will be closed as soon as the task is finished. If an error is encountered during operation, an error will be sent on the channel.

type ReplicaPolicy 

type ReplicaPolicy int

ReplicaPolicy defines type of node partition targeted by read commands. 

const (
	// MASTER reads from node containing key's master partition.
	// This is the default behavior.
	MASTER ReplicaPolicy = iota

	// MASTER_PROLES Distributes reads across nodes containing key's master and replicated partitions
	// in round-robin fashion.
	MASTER_PROLES

	// RANDOM Distribute reads across all nodes in cluster in round-robin fashion.
	// This option is useful when the replication factor equals the number
	// of nodes in the cluster and the overhead of requesting proles is not desired.
	RANDOM

	// SEQUENCE Tries node containing master partition first.
	// If connection fails, all commands try nodes containing replicated partitions.
	// If socketTimeout is reached, reads also try nodes containing replicated partitions,
	// but writes remain on master node.
	SEQUENCE

	// PREFER_RACK Tries nodes on the same rack first.
	//
	// This option requires ClientPolicy.Rackaware to be enabled
	// in order to function properly.
	PREFER_RACK
)

func GetReplicaPolicySC 

func GetReplicaPolicySC(policy *BasePolicy) ReplicaPolicy

GetReplicaPolicySC returns a ReplicaPolicy based on different variables in SC mode

type Result 

type Result struct {
	Record *Record
	Err    Error
}

Result is the value returned by Recordset's Results() function.

func (*Result) String 

func (res *Result) String() string

String implements the Stringer interface

type Role 

type Role struct {
	// Name is role name
	Name string

	// Priviledge is the list of assigned privileges
	Privileges []Privilege

	// While is the list of allowable IP addresses
	Whitelist []string

	// ReadQuota is the maximum reads per second limit for the role
	ReadQuota uint32

	// WriteQuota is the maximum writes per second limit for the role
	WriteQuota uint32
}

Role allows granular access to database entities for users.

type ScanPolicy 

type ScanPolicy struct {
	MultiPolicy
}

ScanPolicy encapsulates parameters used in scan operations.

func NewScanPolicy 

func NewScanPolicy() *ScanPolicy

NewScanPolicy creates a new ScanPolicy instance with default values. Set MaxRetries for scans on server versions >= 4.9. All other scans are not retried.

The latest servers support retries on individual data partitions. This feature is useful when a cluster is migrating and partition(s) are missed or incomplete on the first scan attempt.

If the first scan attempt misses 2 of 4096 partitions, then only those 2 partitions are retried in the next scan attempt from the last key digest received for each respective partition. A higher default MaxRetries is used because it's wasteful to invalidate all scan results because a single partition was missed.

type Statement 

type Statement struct {
	// Namespace determines query Namespace
	Namespace string

	// SetName determines query Set name (Optional)
	SetName string

	// IndexName determines query index name (Optional)
	// If not set, the server will determine the index from the filter's bin name.
	IndexName string

	// BinNames detemines bin names (optional)
	BinNames []string

	// Filter determines query index filter (Optional).
	// This filter is applied to the secondary index on query.
	// Query index filters must reference a bin which has a secondary index defined.
	Filter *Filter

	// TaskId determines query task id. (Optional)
	// This value is not used anymore and will be removed later.
	TaskId uint64
	// contains filtered or unexported fields
}

Statement encapsulates query statement parameters.

func NewStatement 

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

NewStatement initializes a new Statement instance.

func (*Statement) IsScan 

func (stmt *Statement) IsScan() bool

IsScan determines is the Statement is a full namespace/set scan or a selective Query.

func (*Statement) SetAggregateFunction 

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

SetAggregateFunction sets aggregation function parameters. This function will be called on both the server and client for each selected item.

func (*Statement) SetFilter 

func (stmt *Statement) SetFilter(filter *Filter) Error

SetFilter Sets a filter for the statement. Aerospike Server currently only supports using a single filter per statement/query.

type StringValue 

type StringValue string

StringValue encapsulates a string value.

func NewStringValue 

func NewStringValue(value string) StringValue

NewStringValue generates a StringValue instance.

func (StringValue) EstimateSize 

func (vl StringValue) EstimateSize() (int, Error)

EstimateSize returns the size of the StringValue in wire protocol.

func (StringValue) GetObject 

func (vl StringValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (StringValue) GetType 

func (vl StringValue) GetType() int

GetType returns wire protocol value type.

func (StringValue) String 

func (vl StringValue) String() string

String implements Stringer interface.

type Task 

type Task interface {
	IsDone() (bool, Error)

	OnComplete() chan Error
	// contains filtered or unexported methods
}

Task interface defines methods for asynchronous tasks.

type UDF 

type UDF struct {
	// Filename of the UDF
	Filename string
	// Hash digest of the UDF
	Hash string
	// Language of UDF
	Language Language
}

UDF carries information about UDFs on the server

type UserRoles 

type UserRoles struct {
	// User name.
	User string

	// Roles is a list of assigned roles.
	Roles []string

	// ReadInfo is the list of read statistics. List may be nil.
	// Current statistics by offset are:
	//
	// 0: read quota in records per second
	// 1: single record read transaction rate (TPS)
	// 2: read scan/query record per second rate (RPS)
	// 3: number of limitless read scans/queries
	//
	// Future server releases may add additional statistics.
	ReadInfo []int

	// WriteInfo is the list of write statistics. List may be nil.
	// Current statistics by offset are:
	//
	// 0: write quota in records per second
	// 1: single record write transaction rate (TPS)
	// 2: write scan/query record per second rate (RPS)
	// 3: number of limitless write scans/queries
	//
	// Future server releases may add additional statistics.
	WriteInfo []int

	// ConnsInUse is the number of currently open connections for the user
	ConnsInUse int
}

UserRoles contains information about a user.

type Value 

type Value interface {

	// Calculate number of vl.bytes necessary to serialize the value in the wire protocol.
	EstimateSize() (int, Error)

	// GetType returns wire protocol value type.
	GetType() int

	// GetObject returns original value as an interface{}.
	GetObject() interface{}

	// String implements Stringer interface.
	String() string
	// contains filtered or unexported methods
}

Value interface is used to efficiently serialize objects into the wire protocol.

func NewValue 

func NewValue(v interface{}) Value

NewValue generates a new Value object based on the type. If the type is not supported, NewValue will panic. This method is a convenience method, and should not be used when absolute performance is required unless for the reason mentioned below.

If you have custom maps or slices like: 

type MyMap map[primitive1]primitive2, eg: map[int]string

or 

type MySlice []primitive, eg: []float64

cast them to their primitive type when passing them to this method: 

v := NewValue(map[int]string(myVar))
v := NewValue([]float64(myVar))

This way you will avoid hitting reflection. To completely avoid reflection in the library, use the build tag: as_performance while building your program.

type ValueArray 

type ValueArray []Value

ValueArray encapsulates an array of Value. Supported by Aerospike 3+ servers only.

func NewValueArray 

func NewValueArray(array []Value) *ValueArray

NewValueArray generates a ValueArray instance.

func (ValueArray) EstimateSize 

func (va ValueArray) EstimateSize() (int, Error)

EstimateSize returns the size of the ValueArray in wire protocol.

func (ValueArray) GetObject 

func (va ValueArray) GetObject() interface{}

GetObject returns original value as an interface{}.

func (ValueArray) GetType 

func (va ValueArray) GetType() int

GetType returns wire protocol value type.

func (ValueArray) String 

func (va ValueArray) String() string

String implements Stringer interface.

type WildCardValue 

type WildCardValue struct{}

WildCardValue is an empty value.

func NewWildCardValue 

func NewWildCardValue() WildCardValue

NewWildCardValue generates a WildCardValue instance.

func (WildCardValue) EstimateSize 

func (vl WildCardValue) EstimateSize() (int, Error)

EstimateSize returns the size of the WildCardValue in wire protocol.

func (WildCardValue) GetObject 

func (vl WildCardValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (WildCardValue) GetType 

func (vl WildCardValue) GetType() int

GetType returns wire protocol value type.

func (WildCardValue) String 

func (vl WildCardValue) String() string

type WritePolicy 

type WritePolicy struct {
	BasePolicy

	// RecordExistsAction qualifies how to handle writes where the record already exists.
	RecordExistsAction RecordExistsAction //= RecordExistsAction.UPDATE;

	// GenerationPolicy qualifies how to handle record writes based on record generation. The default (NONE)
	// indicates that the generation is not used to restrict writes.
	GenerationPolicy GenerationPolicy //= GenerationPolicy.NONE;

	// Desired consistency guarantee when committing a transaction on the server. The default
	// (COMMIT_ALL) indicates that the server should wait for master and all replica commits to
	// be successful before returning success to the client.
	CommitLevel CommitLevel //= COMMIT_ALL

	// Generation determines expected generation.
	// Generation is the number of times a record has been
	// modified (including creation) on the server.
	// If a write operation is creating a record, the expected generation would be 0.
	Generation uint32

	// Expiration determines record expiration in seconds. Also known as TTL (Time-To-Live).
	// Seconds record will live before being removed by the server.
	// Expiration values:
	// TTLServerDefault (0): Default to namespace configuration variable "default-ttl" on the server.
	// TTLDontExpire (MaxUint32): Never expire for Aerospike 2 server versions >= 2.7.2 and Aerospike 3+ server
	// TTLDontUpdate (MaxUint32 - 1): Do not change ttl when record is written. Supported by Aerospike server versions >= 3.10.1
	// > 0: Actual expiration in seconds.
	Expiration uint32

	// RespondPerEachOp defines for client.Operate() method, return a result for every operation.
	// Some list operations do not return results by default (ListClearOp() for example).
	// This can sometimes make it difficult to determine the desired result offset in the returned
	// bin's result list.
	//
	// Setting RespondPerEachOp to true makes it easier to identify the desired result offset
	// (result offset equals bin's operate sequence). This only makes sense when multiple list
	// operations are used in one operate call and some of those operations do not return results
	// by default.
	RespondPerEachOp bool

	// DurableDelete leaves a tombstone for the record if the transaction results in a record deletion.
	// This prevents deleted records from reappearing after node failures.
	// Valid for Aerospike Server Enterprise Edition 3.10+ only.
	DurableDelete bool
}

WritePolicy encapsulates parameters for policy attributes used in write operations. This object is passed into methods where database writes can occur.

func NewWritePolicy 

func NewWritePolicy(generation, expiration uint32) *WritePolicy

NewWritePolicy initializes a new WritePolicy instance with default parameters.

Source Files

View all Source files

Directories

Path Synopsis
examples
add
append
batch
blob
count_set_objects
custom_list_iter
expire
generation
geojson_query
get
info
list_map
operate
prepend
put
putget
query-aggregate/average
query-aggregate/single_bin_sum
replace
scan_paginate
scan_parallel
scan_serial
shared
simple
tls_secure_connection
touch
udf
internal
atomic
lua
lua/resources
particle_type
pkg
bcrypt
ripemd160
Package ripemd160 implements the RIPEMD-160 hash algorithm.
 Package ripemd160 implements the RIPEMD-160 hash algorithm.
tools
asinfo
benchmark
cli
rand
utils
buffer

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.