aerospike_helpers.batch package

aerospike_helpers.batch.recordsmodule

Classes for the use with client batch APIs batch_write(), batch_operate(), batch_apply(), batch_remove().

class aerospike_helpers.batch.records.Apply(key: tuple, module: str, function: str, args: List[Any], policy: Optional[Dict] = None)

Bases: BatchRecord

BatchApply is used for executing Batch UDF (user defined function) apply operations with batch_write and retrieving results.

key

The aerospike key to operate on.

Type

tuple

module

Name of the lua module previously registerd with the server.

Type

str

function

Name of the UDF to invoke.

Type

str

args

List of arguments to pass to the UDF.

Type

list

record

The record corresponding to the requested key.

Type

Record Tuple

result

The status code of the operation.

Type

int

in_doubt

Is it possible that the write transaction completed even though an error was generated. This may be the case when a client error occurs (like timeout) after the command was sent to the server.

Type

bool

ops

A list of aerospike operation dictionaries to perform on the record at key.

Type

aerospike_helpers.operations package

policy

An optional dictionary of batch apply policy flags.

Type

Batch Apply Policies, optional

__init__(key: tuple, module: str, function: str, args: List[Any], policy: Optional[Dict] = None) None

Example:

# Create a batch Apply to apply UDF "test_func" to bin "a" from the record.
# Assume that "test_func" takes a bin name string as an argument.
# Assume the appropriate UDF module has already been registerd.
import aerospike_helpers.operations as op


module = "my_lua"
function = "test_func"

bin_name = "a"
args = [
    bin_name
]

namespace = "test"
set = "demo"
user_key = 1
key = (namespace, set, user_key)

ba = Apply(key, module, function, args)
class aerospike_helpers.batch.records.BatchRecord(key: tuple)

Bases: object

BatchRecord provides the base fields for BatchRecord objects.

BatchRecord should usually be read from as a result and not created by the user. Its subclasses can be used as input to batch_write. Client methods batch_apply(), batch_operate(), batch_remove() with batch_records field as a list of these BatchRecord objects containing the batch request results.

key

The aerospike key to operate on.

Type

tuple

record

The record corresponding to the requested key.

Type

Record Tuple

result

The status code of the operation.

Type

int

in_doubt

Is it possible that the write transaction completed even though an error was generated. This may be the case when a client error occurs (like timeout) after the command was sent to the server.

Type

bool

__init__(key: tuple) None
__weakref__

list of weak references to the object (if defined)

class aerospike_helpers.batch.records.BatchRecords(batch_records: Optional[List[BatchRecord]] = None)

Bases: object

BatchRecords is used as input and output for multiple batch APIs.

batch_records

A list of BatchRecord subtype objects used to define batch operations and hold results. BatchRecord Types can be Remove, Write, Read, and Apply.

Type

list

result

The status code of the last batch call that used this BatchRecords.

Type

int

0 if all batch subtransactions succeeded
Type

or if the only failures were FILTERED_OUT or RECORD_NOT_FOUND

non 0 if an error occured. The most common error being -16
Type

One or more batch sub transactions failed

__init__(batch_records: Optional[List[BatchRecord]] = None) None

Example:

# Create a BatchRecords to remove a record, write a bin, and read a bin.
# Assume client is an instantiated and connected aerospike cleint.
import aerospike_helpers.operations as op


namespace = "test"
set = "demo"
bin_name = "id"
keys = [
    (namespace, set, 1),
    (namespace, set, 2),
    (namespace, set, 3)
]

brs = BatchRecords(
    [
        Remove(
            key=(namespace, set, 1),
        ),
        Write(
            key=(namespace, set, 100),
            ops=[
                op.write(bin_name, 100),
                op.read(bin_name),
            ]
        ),
        BatchRead(
            key=(namespace, set, 333),
            ops=[
                op.read(bin_name)
            ]
        )
    ]
)

# Note this call will mutate brs and set results in it.
client.batch_write(brs)
__weakref__

list of weak references to the object (if defined)

class aerospike_helpers.batch.records.Read(key: tuple, ops: Optional[List[Dict]], read_all_bins: bool = False, policy: Optional[Dict] = None)

Bases: BatchRecord

Read is used for executing Batch read operations with batch_write and retrieving results.

key

The aerospike key to operate on.

Type

tuple

record

The record corresponding to the requested key.

Type

tuple

result

The status code of the operation.

Type

int

in_doubt

Is it possible that the write transaction completed even though an error was generated. This may be the case when a client error occurs (like timeout) after the command was sent to the server.

Type

bool

ops

list of aerospike operation dictionaries to perform on the record at key.

Type

aerospike_helpers.operations package

read_all_bins

An optional bool, if True, read all bins in the record.

Type

bool, optional

policy

An optional dictionary of batch read policy flags.

Type

Batch Read Policies, optional

__init__(key: tuple, ops: Optional[List[Dict]], read_all_bins: bool = False, policy: Optional[Dict] = None) None

Example:

# Create a batch Read to read bin "a" from the record.
import aerospike_helpers.operations as op


bin_name = "a"

namespace = "test"
set = "demo"
user_key = 1
key = (namespace, set, user_key)

ops = [
    op.read(bin_name)
]

br = Read(key, ops)
class aerospike_helpers.batch.records.Remove(key: tuple, policy: Optional[Dict] = None)

Bases: BatchRecord

Remove is used for executing Batch remove operations with batch_write and retrieving results.

key

The aerospike key to operate on.

Type

tuple

record

The record corresponding to the requested key.

Type

Record Tuple

result

The status code of the operation.

Type

int

in_doubt

Is it possible that the write transaction completed even though an error was generated. This may be the case when a client error occurs (like timeout) after the command was sent to the server.

Type

bool

ops

A list of aerospike operation dictionaries to perform on the record at key.

Type

aerospike_helpers.operations package

policy

An optional dictionary of batch remove policy flags.

Type

Batch Remove Policies, optional

__init__(key: tuple, policy: Optional[Dict] = None) None

Example:

# Create a batch Remove to remove the record.
import aerospike_helpers.operations as op


namespace = "test"
set = "demo"
user_key = 1
key = (namespace, set, user_key)

br = Remove(key, ops)
class aerospike_helpers.batch.records.Write(key: tuple, ops: List[Dict], policy: Optional[Dict] = None)

Bases: BatchRecord

Write is used for executing Batch write operations with batch_write and retrieving batch write results.

key

The aerospike key to operate on.

Type

tuple

record

The record corresponding to the requested key.

Type

tuple

result

The status code of the operation.

Type

int

in_doubt

Is it possible that the write transaction completed even though an error was generated. This may be the case when a client error occurs (like timeout) after the command was sent to the server.

Type

bool

ops

A list of aerospike operation dictionaries to perform on the record at key.

Type

aerospike_helpers.operations package

policy

An optional dictionary of batch write policy flags.

Type

Batch Write Policies, optional

__init__(key: tuple, ops: List[Dict], policy: Optional[Dict] = None) None

Example:

# Create a batch Write to increment bin "a" by 10 and read the result from the record.
import aerospike_helpers.operations as op


bin_name = "a"

namespace = "test"
set = "demo"
user_key = 1
key = (namespace, set, user_key)

ops = [
    op.increment(bin_name, 10),
    op.read(bin_name)
]

bw = Write(key, ops)