aerospike

package module
Version: v4.0.0+incompatible Latest Latest
Warning

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

Go to latest
Published: Nov 27, 2020 License: Apache-2.0 Imports: 35 Imported by: 0

README

Aerospike Go Client

Aerospike Client Go Build Status Godoc

An Aerospike library for Go.

This library is compatible with Go 1.9+ 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.

Notice:

We have released the Go Client v2, with some breaking API changes. Most changes are minor, and can be fixed with relative ease.

The only major issue is that the behavior of the client when a key does not exist has changed.

It used to return no error, but a nil Record.Bins. Now it returns ErrKeyNotFound error.

This is a significant changes, and you should search your code for all instances of Bins == nil and adapt the code accordingly.

Please refer to the CHANGELOG.md for details.

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

// 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.9+ 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.

* Copyright 2012-2019 Aerospike, Inc.
*
* Portions may be licensed to Aerospike, Inc. under one or more contributor
* license agreements WHICH ARE COMPATIBLE WITH THE APACHE LICENSE, VERSION 2.0.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.

* Copyright 2012-2019 Aerospike, Inc.
*
* Portions may be licensed to Aerospike, Inc. under one or more contributor
* license agreements WHICH ARE COMPATIBLE WITH THE APACHE LICENSE, VERSION 2.0.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http: *www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.

Copyright 2013-2020 Aerospike, Inc.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.package aerospike

Copyright 2013-2020 Aerospike, Inc.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2013-2020 Aerospike, Inc.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.package aerospike

Copyright 2013-2020 Aerospike, Inc.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2013-2020 Aerospike, Inc.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.package aerospike

* Copyright 2012-2019 Aerospike, Inc.
*
* Portions may be licensed to Aerospike, Inc. under one or more contributor
* license agreements WHICH ARE COMPATIBLE WITH THE APACHE LICENSE, VERSION 2.0.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.

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 (
	BitExpOpRESIZE   = 0
	BitExpOpINSERT   = 1
	BitExpOpREMOVE   = 2
	BitExpOpSET      = 3
	BitExpOpOR       = 4
	BitExpOpXOR      = 5
	BitExpOpAND      = 6
	BitExpOpNOT      = 7
	BitExpOpLSHIFT   = 8
	BitExpOpRSHIFT   = 9
	BitExpOpADD      = 10
	BitExpOpSUBTRACT = 11
	BitExpOpSETINT   = 12
	BitExpOpGET      = 50
	BitExpOpCOUNT    = 51
	BitExpOpLSCAN    = 52
	BitExpOpRSCAN    = 53
	BitExpOpGETINT   = 54
)
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"

	// 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"
)

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
)
View Source
const MODIFY = 0x40

Variables

View Source
var (
	HllExpOpADD            = 1
	HllExpOpCOUNT          = 50
	HllExpOpUNION          = 51
	HllExpOpUNIONCOUNT     = 52
	HllExpOpINTERSECTCOUNT = 53
	HllExpOpSIMILARITY     = 54
	HllExpOpDESCRIBE       = 55
	HllExpOpMAYCONTAIN     = 56
)
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}}

Map storage order.

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

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

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

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

	// Return reserve value order.
	//
	// 0 = largest value
	// N = Nth largest value
	// -1 = smallest value
	REVERSE_RANK mapReturnType

	// Return count of items selected.
	COUNT mapReturnType

	// Return key for single key read and key list for range read.
	KEY mapReturnType

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

	// 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

	// 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,
}

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
)

Functions

func NewPredExpAnd added in v1.26.0

func NewPredExpAnd(nexpr uint16) *predExpAnd

NewPredExpAnd creates an AND predicate. Argument describes the number of expressions.

func NewPredExpGeoJSONBin added in v1.26.0

func NewPredExpGeoJSONBin(name string) *predExpBin

NewPredExpUnknownBin creates a Bin predicate expression which its type is GeoJSON.

func NewPredExpGeoJSONContains added in v1.26.0

func NewPredExpGeoJSONContains() *predExpCompare

NewPredExpGeoJSONContains creates Region Contains predicate for GeoJSON values

func NewPredExpGeoJSONValue added in v1.26.0

func NewPredExpGeoJSONValue(val string) *predExpGeoJSONValue

NewPredExpGeoJSONValue embeds a GeoJSON value in a predicate expression.

func NewPredExpGeoJSONVar added in v1.26.0

func NewPredExpGeoJSONVar(name string) *predExpVar

NewPredExpGeoJSONVar creates GeoJSON variable used in list/map iterations.

func NewPredExpGeoJSONWithin added in v1.26.0

func NewPredExpGeoJSONWithin() *predExpCompare

NewPredExpGeoJSONWithin creates Within Region predicate for GeoJSON values

func NewPredExpIntegerBin added in v1.26.0

func NewPredExpIntegerBin(name string) *predExpBin

NewPredExpUnknownBin creates a Bin predicate expression which its type is integer.

func NewPredExpIntegerEqual added in v1.26.0

func NewPredExpIntegerEqual() *predExpCompare

NewPredExpIntegerEqual creates Equal predicate for integer values

func NewPredExpIntegerGreater added in v1.26.0

func NewPredExpIntegerGreater() *predExpCompare

NewPredExpIntegerGreater creates Greater Than predicate for integer values

func NewPredExpIntegerGreaterEq added in v1.26.0

func NewPredExpIntegerGreaterEq() *predExpCompare

NewPredExpIntegerGreaterEq creates Greater Than Or Equal predicate for integer values

func NewPredExpIntegerLess added in v1.26.0

func NewPredExpIntegerLess() *predExpCompare

NewPredExpIntegerLess creates Less Than predicate for integer values

func NewPredExpIntegerLessEq added in v1.26.0

func NewPredExpIntegerLessEq() *predExpCompare

NewPredExpIntegerLessEq creates Less Than Or Equal predicate for integer values

func NewPredExpIntegerUnequal added in v1.26.0

func NewPredExpIntegerUnequal() *predExpCompare

NewPredExpIntegerUnequal creates NotEqual predicate for integer values

func NewPredExpIntegerValue added in v1.26.0

func NewPredExpIntegerValue(val int64) *predExpIntegerValue

NewPredExpIntegerValue embeds an int64 value in a predicate expression.

func NewPredExpIntegerVar added in v1.26.0

func NewPredExpIntegerVar(name string) *predExpVar

NewPredExpIntegerVar creates 64 bit integer variable used in list/map iterations.

func NewPredExpListBin added in v1.26.0

func NewPredExpListBin(name string) *predExpBin

NewPredExpUnknownBin creates a Bin predicate expression which its type is List.

func NewPredExpListIterateAnd added in v1.26.0

func NewPredExpListIterateAnd(name string) *predExpIter

NewPredExpListIterateAnd creates an And iterator predicate for list items

func NewPredExpListIterateOr added in v1.26.0

func NewPredExpListIterateOr(name string) *predExpIter

NewPredExpListIterateOr creates an Or iterator predicate for list items

func NewPredExpMapBin added in v1.26.0

func NewPredExpMapBin(name string) *predExpBin

NewPredExpUnknownBin creates a Bin predicate expression which its type is Map.

func NewPredExpMapKeyIterateAnd added in v1.26.0

func NewPredExpMapKeyIterateAnd(name string) *predExpIter

NewPredExpMapKeyIterateAnd creates an And iterator predicate on map keys

func NewPredExpMapKeyIterateOr added in v1.26.0

func NewPredExpMapKeyIterateOr(name string) *predExpIter

NewPredExpMapKeyIterateOr creates an Or iterator predicate on map keys

func NewPredExpMapValIterateAnd added in v1.26.0

func NewPredExpMapValIterateAnd(name string) *predExpIter

NewPredExpMapKeyIterateAnd creates an And iterator predicate on map values

func NewPredExpMapValIterateOr added in v1.26.0

func NewPredExpMapValIterateOr(name string) *predExpIter

NewPredExpMapValIterateOr creates an Or iterator predicate on map values

func NewPredExpNot added in v1.26.0

func NewPredExpNot() *predExpNot

NewPredExpNot creates a NOT predicate

func NewPredExpOr added in v1.26.0

func NewPredExpOr(nexpr uint16) *predExpOr

NewPredExpOr creates an OR predicate. Argument describes the number of expressions.

func NewPredExpRecDeviceSize added in v1.26.0

func NewPredExpRecDeviceSize() *predExpMD

NewPredExpRecDeviceSize creates record size on disk predicate

func NewPredExpRecDigestModulo added in v1.26.0

func NewPredExpRecDigestModulo(mod int32) *predExpMDDigestModulo

NewPredExpRecDigestModulo creates a digest modulo record metadata value predicate expression. The digest modulo expression assumes the value of 4 bytes of the record's key digest modulo as its argument. This predicate is available in Aerospike server versions 3.12.1+

For example, the following sequence of predicate expressions selects records that have digest(key) % 3 == 1): stmt.SetPredExp(

NewPredExpRecDigestModulo(3),
NewPredExpIntegerValue(1),
NewPredExpIntegerEqual(),

)

func NewPredExpRecLastUpdate added in v1.26.0

func NewPredExpRecLastUpdate() *predExpMD

NewPredExpRecLastUpdate creates record last update predicate

func NewPredExpRecVoidTime added in v1.26.0

func NewPredExpRecVoidTime() *predExpMD

NewPredExpRecVoidTime creates record expiration time predicate expressed in nanoseconds since 1970-01-01 epoch as 64 bit integer.

func NewPredExpStringBin added in v1.26.0

func NewPredExpStringBin(name string) *predExpBin

NewPredExpUnknownBin creates a Bin predicate expression which its type is String.

func NewPredExpStringEqual added in v1.26.0

func NewPredExpStringEqual() *predExpCompare

NewPredExpStringEqual creates Equal predicate for string values

func NewPredExpStringRegex added in v1.26.0

func NewPredExpStringRegex(cflags uint32) *predExpStringRegex

NewPredExpStringRegex creates a Regex predicate

func NewPredExpStringUnequal added in v1.26.0

func NewPredExpStringUnequal() *predExpCompare

NewPredExpStringUnequal creates Not Equal predicate for string values

func NewPredExpStringValue added in v1.26.0

func NewPredExpStringValue(val string) *predExpStringValue

NewPredExpStringValue embeds a string value in a predicate expression.

func NewPredExpStringVar added in v1.26.0

func NewPredExpStringVar(name string) *predExpVar

NewPredExpStringVar creates string variable used in list/map iterations.

func NewPredExpUnknownBin added in v1.26.0

func NewPredExpUnknownBin(name string) *predExpBin

NewPredExpUnknownBin creates a Bin predicate expression which its type is not known.

func PackBool added in v1.23.0

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

Pack bool packs a bool value

func PackBytes added in v1.23.0

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

PackBytes backs a byte array

func PackFloat32 added in v1.23.0

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

PackFloat32 packs float32 value

func PackFloat64 added in v1.23.0

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

PackFloat64 packs float64 value

func PackInt64 added in v1.23.0

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

PackInt64 packs an int64

func PackJson added in v1.23.0

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

PackJson packs json data

func PackList added in v1.23.0

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

PackList packs any slice that implement the ListIter interface

func PackMap added in v1.23.0

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

PackMap packs any map that implements the MapIter interface

func PackNil added in v1.23.0

func PackNil(cmd BufferEx) (int, error)

Pack nil packs a nil value

func PackString added in v1.23.0

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

PackString packs a string

func PackUInt64 added in v1.23.0

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

PackUInt64 packs a uint64

func RequestInfo

func RequestInfo(conn *Connection, 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 SetAerospikeTag added in v1.20.0

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 added in v1.10.0

func SetLuaPath(lpath string)

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

Types

type AdminPolicy added in v1.3.0

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 added in v1.3.0

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

type AuthMode added in v1.35.0

type AuthMode int

AuthMode determines authentication mode when user/password is defined.

const (
	// AuthModeInternal uses internal authentication only.  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).  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
)

type BasePolicy

type BasePolicy struct {
	Policy

	// PredExps is the optional predicate expression filter in postfix notation. If the predicate
	// expression exists and evaluates to false, the transaction is ignored.
	//
	// Default: nil
	// NOTE: This feature is deprecated on Aerospike servers and will be removed in the future.
	// It has been replaced by FilterExpressions.
	PredExp []PredExp

	// FilterExpression is the optional Filter Expression. Supported on Server v5.2+
	FilterExpression *FilterExpression

	// Priority of request relative to other transactions.
	// Currently, only used for scans.
	Priority Priority //= Priority.DEFAULT;

	// 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/query/scan: 0 (no retries)
	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;

	// 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 tells the server to compress its response using zlib.
	// Use zlib compression on write or batch read commands when the command buffer size is greater
	// than 128 bytes. In addition, it directs the server to compress its response on read commands.
	// The server response compression threshold is also 128 bytes. Works with server EE v4.8.0.1+.
	//
	// 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 BatchError

type BatchError struct {
	Errors map[*Node]error
}

BatchError is a type to encapsulate the node that the error occurred in.

type BatchPolicy added in v1.31.0

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

	// 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

	// Send set name field to server for every key in the batch for batch index protocol.
	// This is only necessary when authentication is enabled and security roles are defined
	// on a per set basis.
	SendSetName 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 added in v1.31.0

func NewBatchPolicy() *BatchPolicy

NewBatchPolicy initializes a new BatchPolicy instance with default parameters.

type BatchRead added in v1.31.0

type BatchRead struct {
	// Key specifies the key to retrieve.
	Key *Key

	// BinNames specifies the Bins to retrieve for this key.
	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

	// Record result after batch command has completed.  Will be null if record was not found.
	Record *Record
}

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

func NewBatchRead added in v1.31.0

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

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

func NewBatchReadHeader added in v1.31.0

func NewBatchReadHeader(key *Key) *BatchRead

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

func (*BatchRead) String added in v1.31.0

func (br *BatchRead) String() string

String implements the Stringer interface.

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

	// BitOverflowActionFail 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

func NewBitPolicy

func NewBitPolicy(flags int) *BitPolicy

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 BufferEx added in v1.23.0

type BufferEx interface {
	WriteInt64(num int64) (int, error)
	WriteUint64(num uint64) (int, error)
	WriteInt32(num int32) (int, error)
	WriteUint32(num uint32) (int, error)
	WriteInt16(num int16) (int, error)
	WriteUint16(num uint16) (int, error)
	WriteFloat32(float float32) (int, error)
	WriteFloat64(float float64) (int, error)
	WriteByte(b byte) error
	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)

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

Create 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 used for all batch commands without a specific policy.
	DefaultBatchPolicy *BatchPolicy
	// 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
	// contains filtered or unexported fields
}

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

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 (*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) BatchExists added in v1.0.1

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 added in v1.0.1

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 added in v1.31.0

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 null. The policy can be used to specify timeouts and maximum concurrent threads. This method requires Aerospike Server version >= 3.6.0.

func (*Client) BatchGetHeader added in v1.0.1

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 added in v1.27.0

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

BatchGetObject 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) ChangePassword added in v1.3.0

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 added in v1.23.0

func (clnt *Client) Cluster() *Cluster

Cluster exposes the cluster object to the user

func (*Client) CreateComplexIndex added in v1.7.0

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 added in v1.0.1

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 added in v1.24.0

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

CreateRole creates a user-defined role.

func (*Client) CreateUser added in v1.3.0

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 added in v1.0.1

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 added in v1.24.0

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

DropRole removes a user-defined role.

func (*Client) DropUser added in v1.3.0

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

DropUser removes a user from the cluster.

func (*Client) Execute added in v1.0.1

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 added in v1.0.1

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 added in v1.30.0

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 added in v1.4.0

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 added in v1.24.0

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

GrantPrivileges grant privileges to a user-defined role.

func (*Client) GrantRoles added in v1.3.0

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 added in v1.0.1

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 added in v1.0.1

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 added in v1.4.0

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 added in v1.0.1

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 added in v1.10.0

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 added in v1.3.0

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 added in v1.8.0

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 added in v1.8.0

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

QueryNodeObjects 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) QueryRole added in v1.24.0

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

QueryRole retrieves privileges for a given role.

func (*Client) QueryRoles added in v1.24.0

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

QueryRoles retrieves all roles and their privileges.

func (*Client) QueryUser added in v1.3.0

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

QueryUser retrieves roles for a given user.

func (*Client) QueryUsers added in v1.3.0

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

QueryUsers retrieves all users and their roles.

func (*Client) RegisterUDF added in v1.0.1

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 added in v1.0.1

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 added in v1.0.1

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 added in v1.24.0

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

RevokePrivileges revokes privileges from a user-defined role.

func (*Client) RevokeRoles added in v1.3.0

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

RevokeRoles removes roles from user's list of roles.

func (*Client) ScanAll added in v1.0.1

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 added in v1.8.0

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 added in v1.0.1

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 added in v1.8.0

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) 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) Stats added in v1.28.0

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 added in v1.11.0

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 added in v1.26.0

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 null, 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

	// 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.
	RackId int // 0

	// 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 added in v1.3.0

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 NewCluster

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

NewCluster generates a Cluster instance.

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 added in v1.5.1

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 added in v1.23.0

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 added in v1.23.0

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

GetSeeds returns a list of all seed nodes in the cluster

func (*Cluster) IsConnected

func (clstr *Cluster) IsConnected() bool

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

func (*Cluster) MigrationInProgress added in v1.0.1

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 added in v1.5.1

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

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

func (*Cluster) String added in v1.11.0

func (clstr *Cluster) String() string

String implements the stringer interface

func (*Cluster) WaitUntillMigrationIsFinished added in v1.0.1

func (clstr *Cluster) WaitUntillMigrationIsFinished(timeout time.Duration) (err 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 added in v1.2.0

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 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 (*Connection) Authenticate added in v1.5.0

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

Authenticate will send authentication information to the server. Notice: This method does not support external authentication mechanisms like LDAP. This method is deprecated and will be removed in the future.

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, err error)

Read reads from connection buffer to the provided slice.

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, err error)

Write writes the slice to the connection buffer.

type DropIndexTask added in v1.17.0

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

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

func NewDropIndexTask added in v1.17.0

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

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

func (*DropIndexTask) IsDone added in v1.17.0

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

IsDone queries all nodes for task completion status.

func (*DropIndexTask) OnComplete added in v1.17.0

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 ExecuteTask added in v1.0.1

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

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

func NewExecuteTask added in v1.0.1

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

NewExecuteTask initializes task with fields needed to query server nodes.

func (*ExecuteTask) IsDone added in v1.0.1

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

IsDone queries all nodes for task completion status.

func (*ExecuteTask) OnComplete added in v1.0.1

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

	// ExpRegexFlagICASE does not differentiate cases.
	ExpRegexFlagICASE ExpRegexFlags = 2

	// ExpRegexFlagNOSUB does not report position of matches.
	ExpRegexFlagNOSUB ExpRegexFlags = 3

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

type ExpType

type ExpType uint
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 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
	SCAN_TIMEOUT         FieldType = 9
	RECORDS_PER_SECOND   FieldType = 10
	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 added in v1.0.1

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

Filter specifies a query filter definition.

func NewContainsFilter added in v1.7.0

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

NewContainsFilter creates a contains filter for query on collection index.

func NewContainsRangeFilter added in v1.7.0

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 added in v1.0.1

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

NewEqualFilter creates a new equality filter instance for query.

func NewGeoRegionsContainingPointFilter added in v1.9.0

func NewGeoRegionsContainingPointFilter(binName, point string) *Filter

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

func NewGeoRegionsContainingPointForCollectionFilter added in v1.13.0

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 added in v1.9.0

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 added in v1.13.0

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 added in v1.9.0

func NewGeoWithinRegionFilter(binName, region string) *Filter

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

func NewGeoWithinRegionForCollectionFilter added in v1.13.0

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 added in v1.0.1

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)

func (*Filter) IndexCollectionType added in v1.7.0

func (fltr *Filter) IndexCollectionType() IndexCollectionType

IndexType return filter's index type.

type FilterExpression

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

Filter expression, which can be applied to most commands, to control which records are affected by the command. Filter expression are created using the functions in the [expressions](crate::expressions) module and its submodules.

func ExpAnd

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

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

func ExpBinExists

func ExpBinExists(name string) *FilterExpression

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

func ExpBinType

func ExpBinType(name string) *FilterExpression

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

func ExpBitAdd

func ExpBitAdd(
	policy *BitPolicy,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	signed bool,
	action BitOverflowAction,
	bin *FilterExpression,
) *FilterExpression

Create 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,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

Create 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(
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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

func ExpBitGet

func ExpBitGet(
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

Create expression that returns bits from byte[] bin starting at bitOffset for bitSize.

func ExpBitGetInt

func ExpBitGetInt(
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	signed bool,
	bin *FilterExpression,
) *FilterExpression

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,
	byte_offset *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

Create expression that inserts value bytes into byte[] bin at byteOffset and returns byte[].

func ExpBitLScan

func ExpBitLScan(
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

Create 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,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	shift *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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

func ExpBitNot

func ExpBitNot(
	policy *BitPolicy,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

Create expression that negates byte[] bin starting at bitOffset for bitSize and returns byte[].

func ExpBitOr

func ExpBitOr(
	policy *BitPolicy,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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

func ExpBitRScan

func ExpBitRScan(
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

Create 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,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	shift *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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

func ExpBitRemove

func ExpBitRemove(
	policy *BitPolicy,
	byte_offset *FilterExpression,
	byte_size *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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

func ExpBitResize

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

Create expression that resizes byte[] to byteSize according to resizeFlags and returns byte[].

func ExpBitSet

func ExpBitSet(
	policy *BitPolicy,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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

func ExpBitSetInt

func ExpBitSetInt(
	policy *BitPolicy,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

Create 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,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	signed bool,
	action BitOverflowAction,
	bin *FilterExpression,
) *FilterExpression

Create 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,
	bit_offset *FilterExpression,
	bit_size *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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

func ExpBlobBin

func ExpBlobBin(name string) *FilterExpression

ExpBlobBin creates a blob bin expression.

func ExpBlobVal

func ExpBlobVal(val []byte) *FilterExpression

createss Blob bin value

func ExpBoolVal

func ExpBoolVal(val bool) *FilterExpression

createss a Boolean value

func ExpDeviceSize

func ExpDeviceSize() *FilterExpression

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) *FilterExpression

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

func ExpEq

ExpEq creates a equal (==) expression.

func ExpFloatBin

func ExpFloatBin(name string) *FilterExpression

ExpFloatBin creates a 64 bit float bin expression.

func ExpFloatVal

func ExpFloatVal(val float64) *FilterExpression

createss 64 bit float bin value

func ExpGeoBin

func ExpGeoBin(name string) *FilterExpression

ExpGeoBin creates a geo bin expression.

func ExpGeoCompare

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

ExpGeoCompare creates a compare geospatial operation.

func ExpGeoVal

func ExpGeoVal(val string) *FilterExpression

ExpGeoVal creates a geospatial json string value.

func ExpGreater

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

ExpGreater creates a greater than (>) operation.

func ExpGreaterEq

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

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

func ExpHLLAdd

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

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 *FilterExpression,
	index_bit_count *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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 *FilterExpression,
	index_bit_count *FilterExpression,
	min_hash_count *FilterExpression,
	bin *FilterExpression,
) *FilterExpression

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) *FilterExpression

ExpHLLBin creates a a HLL bin expression

func ExpHLLDescribe

func ExpHLLDescribe(bin *FilterExpression) *FilterExpression

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 *FilterExpression) *FilterExpression

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

func ExpHLLGetIntersectCount

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

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 *FilterExpression, bin *FilterExpression) *FilterExpression

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

func ExpHLLGetUnion

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

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 *FilterExpression, bin *FilterExpression) *FilterExpression

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

func ExpHLLMayContain

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

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

func ExpIntBin

func ExpIntBin(name string) *FilterExpression

ExpIntBin creates a 64 bit int bin expression.

func ExpIntVal

func ExpIntVal(val int64) *FilterExpression

createss 64 bit integer value

func ExpIsTombstone

func ExpIsTombstone() *FilterExpression

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(exp_type ExpType) *FilterExpression

ExpKey creates a record key expression of specified type.

func ExpKeyExists

func ExpKeyExists() *FilterExpression

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() *FilterExpression

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 *FilterExpression, right *FilterExpression) *FilterExpression

ExpLess creates a less than (<) operation.

func ExpLessEq

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

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

func ExpListAppend

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

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

func ExpListAppendItems

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

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

func ExpListBin

func ExpListBin(name string) *FilterExpression

ExpListBin creates a list bin expression.

func ExpListClear

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

ExpListClear creates an expression that removes all items in list.

func ExpListGetByIndex

func ExpListGetByIndex(
	returnType ListReturnType,
	value_type ExpType,
	index *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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,
	value_type ExpType,
	rank *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpListGetByValueRange

func ExpListGetByValueRange(
	returnType ListReturnType,
	value_begin *FilterExpression,
	value_end *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	rank *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	rank *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpListInsert

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

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

func ExpListInsertItems

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

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

func ExpListRemoveByIndex

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

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

func ExpListRemoveByIndexRange

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

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

func ExpListRemoveByIndexRangeCount

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

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

func ExpListRemoveByRank

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

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

func ExpListRemoveByRankRange

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

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

func ExpListRemoveByRankRangeCount

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

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

func ExpListRemoveByValue

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

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

func ExpListRemoveByValueList

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

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

func ExpListRemoveByValueRange

func ExpListRemoveByValueRange(
	value_begin *FilterExpression,
	value_end *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpListRemoveByValueRelativeRankRange

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

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 *FilterExpression,
	rank *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpListSize

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

ExpListSize creates an expression that returns list size.

func ExpListSort

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

ExpListSort creates an expression that sorts list according to sortFlags.

func ExpListVal

func ExpListVal(val ...Value) *FilterExpression

ExpListVal creates a List bin Value

func ExpListValueVal

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

ExpListValueVal creates a List bin Value

func ExpMapBin

func ExpMapBin(name string) *FilterExpression

ExpMapBin creates a map bin expression.

func ExpMapClear

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

ExpMapClear creates an expression that removes all items in map.

func ExpMapGetByIndex

func ExpMapGetByIndex(
	return_type mapReturnType,
	value_type ExpType,
	index *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapGetByIndexRange

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

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(
	return_type mapReturnType,
	index *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapGetByKey

func ExpMapGetByKey(
	return_type mapReturnType,
	value_type ExpType,
	key *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapGetByKeyList

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

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

func ExpMapGetByKeyRange

func ExpMapGetByKeyRange(
	return_type mapReturnType,
	key_begin *FilterExpression,
	key_end *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapGetByKeyRelativeIndexRange

func ExpMapGetByKeyRelativeIndexRange(
	return_type mapReturnType,
	key *FilterExpression,
	index *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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(
	return_type mapReturnType,
	key *FilterExpression,
	index *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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(
	return_type mapReturnType,
	value_type ExpType,
	rank *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapGetByRankRange

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

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(
	return_type mapReturnType,
	rank *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapGetByValue

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

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

func ExpMapGetByValueList

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

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

func ExpMapGetByValueRange

func ExpMapGetByValueRange(
	return_type mapReturnType,
	value_begin *FilterExpression,
	value_end *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

Expression returns selected data specified by returnType.

func ExpMapGetByValueRelativeRankRange

func ExpMapGetByValueRelativeRankRange(
	return_type mapReturnType,
	value *FilterExpression,
	rank *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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(
	return_type mapReturnType,
	value *FilterExpression,
	rank *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	incr *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	value *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapPutItems

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

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

func ExpMapRemoveByIndex

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

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

func ExpMapRemoveByIndexRange

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

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

func ExpMapRemoveByIndexRangeCount

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

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

func ExpMapRemoveByKey

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

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

func ExpMapRemoveByKeyList

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

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

func ExpMapRemoveByKeyRange

func ExpMapRemoveByKeyRange(
	key_begin *FilterExpression,
	key_end *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapRemoveByKeyRelativeIndexRange

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

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 *FilterExpression,
	index *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapRemoveByRankRange

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

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

func ExpMapRemoveByRankRangeCount

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

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

func ExpMapRemoveByValue

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

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

func ExpMapRemoveByValueList

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

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

func ExpMapRemoveByValueRange

func ExpMapRemoveByValueRange(
	value_begin *FilterExpression,
	value_end *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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

func ExpMapRemoveByValueRelativeRankRange

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

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 *FilterExpression,
	rank *FilterExpression,
	count *FilterExpression,
	bin *FilterExpression,
	ctx ...*CDTContext,
) *FilterExpression

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 *FilterExpression, ctx ...*CDTContext) *FilterExpression

ExpMapSize creates an expression that returns list size.

func ExpMapVal

func ExpMapVal(val MapValue) *FilterExpression

ExpMapVal creates a Map bin Value

func ExpNilValue

func ExpNilValue() *FilterExpression

ExpNil creates a a Nil Value

func ExpNot

func ExpNot(exp *FilterExpression) *FilterExpression

ExpNot creates a "not" operator expression.

func ExpNotEq

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

ExpNotEq creates a not equal (!=) expression

func ExpOr

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

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

func ExpRegexCompare

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

ExpRegexCompare creates a function like regular expression string operation.

func ExpSetName

func ExpSetName() *FilterExpression

ExpSetName creates a function that returns record set name string.

func ExpSinceUpdate

func ExpSinceUpdate() *FilterExpression

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) *FilterExpression

ExpStringBin creates a string bin expression.

func ExpStringVal

func ExpStringVal(val string) *FilterExpression

createss String bin value

func ExpTTL

func ExpTTL() *FilterExpression

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

func ExpValueArrayVal

func ExpValueArrayVal(val ValueArray) *FilterExpression

ExpValueArrayVal creates a List bin Value

func ExpVoidTime

func ExpVoidTime() *FilterExpression

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

type FloatValue added in v1.7.0

type FloatValue float64

FloatValue encapsulates an float64 value.

func NewFloatValue added in v1.7.0

func NewFloatValue(value float64) FloatValue

NewFloatValue generates a FloatValue instance.

func (FloatValue) EstimateSize

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

func (FloatValue) GetObject added in v1.7.0

func (vl FloatValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (FloatValue) GetType added in v1.7.0

func (vl FloatValue) GetType() int

GetType returns wire protocol value type.

func (FloatValue) String added in v1.7.0

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 added in v1.7.0

type GeoJSONValue string

GeoJSONValue encapsulates a 2D Geo point. Supported by Aerospike 3.6.1 servers and later only.

func NewGeoJSONValue added in v1.7.0

func NewGeoJSONValue(value string) GeoJSONValue

NewMapValue generates a GeoJSONValue instance.

func (GeoJSONValue) EstimateSize

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

func (GeoJSONValue) GetObject added in v1.7.0

func (vl GeoJSONValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (GeoJSONValue) GetType added in v1.7.0

func (vl GeoJSONValue) GetType() int

GetType returns wire protocol value type.

func (GeoJSONValue) String added in v1.7.0

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)

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 added in v1.7.0

type IndexCollectionType int

IndexCollectionType is the secondary index collection type.

const (

	// Normal scalar index.
	ICT_DEFAULT IndexCollectionType = iota

	// LIST is Index list elements.
	ICT_LIST

	// MAPKEYS is Index map keys.
	ICT_MAPKEYS

	// MAPVALUES is Index map values.
	ICT_MAPVALUES
)

type IndexTask added in v1.0.1

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

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

func NewIndexTask added in v1.0.1

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

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

func (*IndexTask) IsDone added in v1.0.1

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

IsDone queries all nodes for task completion status.

func (*IndexTask) OnComplete added in v1.0.1

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 added in v1.0.1

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"

	// 2-dimensional spherical geospatial index.
	GEO2DSPHERE IndexType = "GEO2DSPHERE"
)

type InfinityValue added in v1.37.0

type InfinityValue struct{}

InfinityValue is an empty value.

func NewInfinityValue added in v1.37.0

func NewInfinityValue() InfinityValue

NewInfinityValue generates a InfinityValue instance.

func (InfinityValue) EstimateSize

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

func (InfinityValue) GetObject added in v1.37.0

func (vl InfinityValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (InfinityValue) GetType added in v1.37.0

func (vl InfinityValue) GetType() int

GetType returns wire protocol value type.

func (InfinityValue) String added in v1.37.0

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)

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 added in v1.20.0

type JsonValue map[string]interface{}

JsonValue encapsulates a Json map. Supported by Aerospike 3+ servers only.

func NewJsonValue added in v1.20.0

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

NewMapValue generates a JsonValue instance.

func (JsonValue) EstimateSize

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

func (JsonValue) GetObject added in v1.20.0

func (vl JsonValue) GetObject() interface{}

GetObject returns original value as an interface{}.

func (JsonValue) GetType added in v1.20.0

func (vl JsonValue) GetType() int

GetType returns wire protocol value type.

func (JsonValue) String added in v1.20.0

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 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 added in v1.2.0

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 (*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) SetDigest added in v1.2.0

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 added in v1.25.0

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 added in v1.0.1

func (ky *Key) String() string

String implements Stringer interface and returns string representation of key.

func (*Key) Value added in v1.0.1

func (ky *Key) Value() Value

Value returns key's value.

type Language added in v1.0.1

type Language string

Language specifies User defined function languages.

const (

	// LUA embedded programming language.
	LUA Language = "LUA"
)

type ListIter added in v1.20.0

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

/*
	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"
)

/*
	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"
)

/*
	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 added in v1.33.0

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 added in v1.33.0

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

ListPolicy directives when creating a list and writing list items.

func DefaultListPolicy added in v1.33.0

func DefaultListPolicy() *ListPolicy

DefaultListPolicy returns the default policy for CDT list operations.

func NewListPolicy added in v1.33.0

func NewListPolicy(order ListOrderType, flags int) *ListPolicy

Create unique key map with specified order when map does not exist. Use specified write mode when writing map items.

type ListReturnType added in v1.33.0

type ListReturnType int

ListReturnType determines the returned values in CDT List operations.

const (
	// Do not return a result.
	ListReturnTypeNone ListReturnType = 0

	// Return index offset order.
	// 0 = first key
	// N = Nth key
	// -1 = last key
	ListReturnTypeIndex ListReturnType = 1

	// Return reverse index offset order.
	// 0 = last key
	// -1 = first key
	ListReturnTypeReverseIndex ListReturnType = 2

	// Return value order.
	// 0 = smallest value
	// N = Nth smallest value
	// -1 = largest value
	ListReturnTypeRank ListReturnType = 3

	// Return reserve value order.
	// 0 = largest value
	// N = Nth largest value
	// -1 = smallest value
	ListReturnTypeReverseRank ListReturnType = 4

	// Return count of items selected.
	ListReturnTypeCount ListReturnType = 5

	// Return value for single key read and value list for range read.
	ListReturnTypeValue ListReturnType = 7

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

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 added in v1.20.0

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

ListerValue encapsulates any arbitrary array. Supported by Aerospike 3+ servers only.

func NewListerValue added in v1.20.0

func NewListerValue(list ListIter) *ListerValue

NewListValue generates a ListValue instance.

func (*ListerValue) EstimateSize

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

func (*ListerValue) GetObject added in v1.20.0

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

GetObject returns original value as an interface{}.

func (*ListerValue) GetType added in v1.20.0

func (vl *ListerValue) GetType() int

GetType returns wire protocol value type.

func (*ListerValue) String added in v1.20.0

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)

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 added in v1.20.0

type MapIter interface {
	PackMap(buf BufferEx) (int, error)
	Len() int
}
	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"
)

/*
	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 added in v1.16.0

type MapPair struct{ Key, Value interface{} }

Map pair 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 added in v1.16.0

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

MapPolicy directives when creating a map and writing map items.

func DefaultMapPolicy added in v1.16.0

func DefaultMapPolicy() *MapPolicy

DefaultMapPolicy returns the default map policy

func NewMapPolicy added in v1.16.0

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

NewMapPolicy creates a MapPolicy with WriteMode. Use with servers before v4.3

func NewMapPolicyWithFlags added in v1.35.0

func NewMapPolicyWithFlags(order mapOrderType, flags int) *MapPolicy

NewMapPolicyWithFlags creates a MapPolicy with WriteFlags. Use with servers v4.3+

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)

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 added in v1.20.0

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 added in v1.20.0

func NewMapperValue(vmap MapIter) *MapperValue

NewMapValue generates a MapperValue instance.

func (*MapperValue) EstimateSize

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

func (*MapperValue) GetObject added in v1.20.0

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

GetObject returns original value as an interface{}.

func (*MapperValue) GetType added in v1.20.0

func (vl *MapperValue) GetType() int

GetType returns wire protocol value type.

func (*MapperValue) String added in v1.20.0

func (vl *MapperValue) String() string

type MultiPolicy added in v1.0.2

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.
	MaxConcurrentNodes int

	// FailOnClusterChange determines scan termination if cluster is in fluctuating state.
	FailOnClusterChange bool

	// 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 added in v1.0.2

func NewMultiPolicy() *MultiPolicy

NewMultiPolicy initializes a MultiPolicy instance with default values.

type Node

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

Node represents an Aerospike Database Server Node

func GetNodeBatchRead

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

GetNodeBatchRead returns a node for batch reads

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 added in v1.6.0

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 added in v1.0.1

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

MigrationInProgress determines if the node is participating in a data migration

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 added in v1.36.0

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

Rack returns the rack number for the namespace.

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 added in v1.12.0

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 (node *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) WaitUntillMigrationIsFinished added in v1.0.1

func (nd *Node) WaitUntillMigrationIsFinished(timeout time.Duration) (err 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 NodeError added in v1.0.1

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

NodeError is a type to encapsulate the node that the error occurred in.

func (*NodeError) Err added in v1.24.0

func (ne *NodeError) Err() error

Err returns the error

func (*NodeError) Error

func (ne *NodeError) Error() string

Err returns the error

func (*NodeError) Node added in v1.0.1

func (ne *NodeError) Node() *Node

Node returns the node where the error occurred.

type NullValue

type NullValue struct{}

NullValue is an empty value.

func NewNullValue added in v1.0.1

func NewNullValue() NullValue

NewNullValue generates a NullValue instance.

func (NullValue) EstimateSize

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

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 Operation

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

Operation contains operation definition. This struct is used in client's operate() method.

func AddOp added in v1.0.1

func AddOp(bin *Bin) *Operation

AddOp creates integer add database operation.

func AppendOp added in v1.0.1

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, {@link 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 {@link 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, {@link 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

DeteleOp creates delete record database operation.

func GetHeaderOp added in v1.0.1

func GetHeaderOp() *Operation

GetHeaderOp creates read record header database operation.

func GetOp added in v1.0.1

func GetOp() *Operation

GetOp creates read all record bins database operation.

func GetOpForBin added in v1.0.1

func GetOpForBin(binName string) *Operation

GetOpForBin creates read bin 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

Create 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

Create 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

Create 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

Create 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

Create 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

Create 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

Create 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

Create 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

Create 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 added in v1.9.0

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 added in v1.33.0

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 added in v1.9.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 null, the range is less than valueEnd. If valueEnd is null, the range is greater than equal to valueBegin. Server returns selected data specified by returnType.

func ListGetByValueRelativeRankRangeCountOp added in v1.37.0

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 added in v1.37.0

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 added in v1.9.0

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 added in v1.11.0

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 added in v1.9.0

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 added in v1.33.0

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

ListIncrementOp creates list increment operation with policy. Server increments list[index] by 1. Server returns list[index] after incrementing.

func ListIncrementByOneWithPolicyOp added in v1.33.0

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 added in v1.29.0

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 added in v1.33.0

func ListIncrementWithPolicyOp(policy *ListPolicy, binName string, index int, value interface{}, ctx ...*CDTContext) *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 ListInsertOp added in v1.9.0

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 added in v1.33.0

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 added in v1.9.0

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 added in v1.11.0

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 added in v1.9.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.33.0

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 added in v1.37.0

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 added in v1.37.0

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 added in v1.9.0

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 added in v1.11.0

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 added in v1.9.0

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 added in v1.9.0

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 added in v1.33.0

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

ListSetOrderOp creates a set list order operation. Server sets list order. Server returns null.

func ListSizeOp added in v1.9.0

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

ListSizeOp creates a list size operation. Server returns size of list on bin name.

func ListSortOp added in v1.33.0

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 added in v1.9.0

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 added in v1.16.0

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

MapClearOp creates map clear operation. Server removes all items in map. Server returns null.

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.33.0

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 added in v1.16.0

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 added in v1.16.0

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 null, the range is less than keyEnd. If keyEnd is null, the range is greater than equal to keyBegin.

Server returns selected data specified by returnType.

func MapGetByKeyRelativeIndexRangeCountOp added in v1.37.0

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 {@link MapReturnType}). <p> Examples for ordered map [{0=17},{4=2},{5=15},{9=10}]: <ul> <li>(value,index,count) = [selected items]</li> <li>(5,0,1) = [{5=15}]</li> <li>(5,1,2) = [{9=10}]</li> <li>(5,-1,1) = [{4=2}]</li> <li>(3,2,1) = [{9=10}]</li> <li>(3,-2,2) = [{0=17}]</li>

func MapGetByKeyRelativeIndexRangeOp added in v1.37.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.33.0

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

func MapGetByValueOp added in v1.16.0

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 added in v1.16.0

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 null, the range is less than valueEnd. If valueEnd is null, the range is greater than equal to valueBegin.

Server returns selected data specified by returnType.

func MapGetByValueRelativeRankRangeCountOp added in v1.37.0

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 added in v1.37.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 null, the range is less than keyEnd. If keyEnd is null, the range is greater than equal to keyBegin.

Server returns removed data specified by returnType.

func MapRemoveByKeyRelativeIndexRangeCountOp added in v1.37.0

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

Create 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 added in v1.37.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 added in v1.16.0

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 null, the range is less than valueEnd. If valueEnd is null, the range is greater than equal to valueBegin.

Server returns removed data specified by returnType.

func MapRemoveByValueRelativeRankRangeCountOp added in v1.37.0

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 {@link 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 added in v1.37.0

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 added in v1.16.0

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

MapSetPolicyOp creates set map policy operation. Server sets map policy attributes. Server returns null.

The required map policy attributes can be changed after the map is created.

func MapSizeOp added in v1.16.0

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

MapSizeOp creates map size operation. Server returns size of map.

func PrependOp added in v1.0.1

func PrependOp(bin *Bin) *Operation

PrependOp creates string prepend database operation.

func PutOp added in v1.0.1

func PutOp(bin *Bin) *Operation

PutOp creates set database operation.

func TouchOp added in v1.0.1

func TouchOp() *Operation

TouchOp creates touch record database operation.

type OperationType

type OperationType *struct{ op byte }

OperationType determines operation type

type Partition

type Partition struct {
	Namespace   string
	PartitionId int
	// contains filtered or unexported fields
}

Partition encapsulates partition information.

func NewPartition

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

NewPartition returns a partition representation

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 (*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)

PrepareRetryRead increases sequence number before write retries

func (*Partition) String

func (ptn *Partition) String() string

String implements the Stringer interface.

type Partitions added in v1.32.0

type Partitions struct {
	Replicas [][]*Node
	SCMode   bool
	// contains filtered or unexported fields
}

type Policy

type Policy interface {
	// Retrieves BasePolicy
	GetBasePolicy() *BasePolicy
	// contains filtered or unexported methods
}

Policy Interface

type PredExp added in v1.29.0

type PredExp interface {
	String() string
	// contains filtered or unexported methods
}

type Priority

type Priority int

Priority of operations on database server. Currently, this only affects Scan operations.

const (

	// DEFAULT determines that the server defines the priority.
	DEFAULT Priority = iota

	// LOW determines that the server should run the operation in a background thread.
	LOW

	// MEDIUM determines that the server should run the operation at medium priority.
	MEDIUM

	// HIGH determines that the server should run the operation at the highest priority.
	HIGH
)

type Privilege added in v1.24.0

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
}

QueryPolicy encapsulates parameters for policy attributes used in query operations.

func NewQueryPolicy added in v1.0.1

func NewQueryPolicy() *QueryPolicy

NewQueryPolicy generates a new QueryPolicy instance with default values.

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 (
	// ONE indicates that a single node should be involved in the read operation.
	ReadModeAPOne ReadModeAP = iota

	// ALL 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 added in v1.0.1

type Recordset struct {

	// Records is a channel on which the resulting records will be sent back.
	// NOTE: Do not use Records directly. Range on channel returned by Results() instead.
	// Will be unexported in the future
	Records chan *Record
	// contains filtered or unexported fields
}

Recordset encapsulates the result of Scan and Query commands.

func (*Recordset) Close added in v1.0.1

func (rcs *Recordset) Close() error

Close all streams from different nodes. A successful close return nil, subsequent calls to the method will return ErrRecordsetClosed.

func (*Recordset) IsActive added in v1.0.1

func (rcs *Recordset) IsActive() bool

IsActive returns true if the operation hasn't been finished or cancelled.

func (*Recordset) Read added in v1.14.0

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

Read reads the next record from the Recordset. If the Recordset has been closed, it returns ErrRecordsetClosed.