Map bin operations

For the complete documentation index see: llms.txt

All documentation pages available in markdown.

Aerospike map bin expressions read and modify map-type bins inside filter, operation, and projection pipelines. Use them with comparison and logic expressions when you need a Boolean filter, or compose them with record storage typed-bin readers (bin_map) when you need the map value first.

Map operations that read stored data evaluate to unknown when the underlying bin or key is missing, the type does not match, or the value is not yet available during the metadata-only phase of filter evaluation. See Record storage and the expressions overview execution model.

In each operation, the map operand (map_bin_expr in the argument tables) is any map-valued expression: not only a named map bin, but also the result of another expression that evaluates to a map. Map operations compose by passing those values as the map input—for example, taking the size of a map after a put. For nested collection data and path filters, see Querying collection data types and Path expressions.

This reference covers read operations (size, get-by-key, get-by-value, index and rank variants, ranges, and the map_keys/map_values extraction helpers) and modify operations (put, put_items, increment, clear, and remove_by_* variants). Map modify expressions evaluate on a temporary map value; they do not persist unless used in a write operation that stores the result. Map operations change the copy of the map bin in place.

Composing expressions

The map_put reference includes an example that wraps MapExp.put in MapExp.size—the same modify-then-read pattern described above. Many other modify operations show similar composition: their examples nest another map expression as the map operand (map_bin_expr in the arguments table).

Extraction helpers

The map_keys and map_values expressions (server 8.1.2+) are on the Exp class, not MapExp. They take a single map-valued expression and return a list—no context or return_type parameter. Use them to convert a map to a list of its keys or values for further expression processing, for example with in_list.

Modify

`map_clear`

map_clear(context, bin)

Description

Clear all elements in map bin.

Arguments

Name	Type
`context`	`library_specific`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using an empty map after map_clear.

import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(Exp.eq(MapExp.size(MapExp.clear(Exp.mapBin("stock"))), Exp.val(0)));

from aerospike_helpers.expressions import Eq, MapBin
from aerospike_helpers.expressions.map import MapClear, MapSize

exp = Eq(MapSize(None, MapClear(None, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_size(NULL, as_exp_map_clear(NULL, as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(as.ExpMapSize(as.ExpMapClear(as.ExpMapBin("stock"))), as.ExpIntVal(0))

Expression exp = Exp.Build(
  Exp.EQ(MapExp.Size(MapExp.Clear(Exp.MapBin("stock"))), Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp

const filterExp = exp.eq(exp.maps.size(exp.maps.clear(exp.binMap('stock'))), exp.int(0))

`map_increment`

map_increment(context, policy, key, delta, bin)

Description

Increment element at key by delta.

Arguments

Name	Type
`context`	`library_specific`
`policy`	`library_specific`
`key`	`expr`
`delta`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the value at sku-a after incrementing it by 5.

import com.aerospike.client.cdt.MapPolicy;
import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.eq(
        MapExp.getByKey(
            MapReturnType.VALUE,
            Exp.Type.INT,
            Exp.val("sku-a"),
            MapExp.increment(MapPolicy.Default, Exp.val("sku-a"), Exp.val(5), Exp.mapBin("stock"))),
        Exp.val(100)));

import aerospike
from aerospike_helpers.expressions import Eq, MapBin, ResultType
from aerospike_helpers.expressions.map import MapGetByKey, MapIncrement

exp = Eq(
    MapGetByKey(
        None,
        aerospike.MAP_RETURN_VALUE,
        ResultType.INTEGER,
        "sku-a",
        MapIncrement(None, None, "sku-a", 5, MapBin("stock")),
    ),
    100,
).compile()

as_map_policy mp;
as_map_policy_init(&mp);
as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_get_by_key(
      NULL,
      AS_MAP_RETURN_VALUE,
      AS_EXP_TYPE_INT,
      as_exp_str("sku-a"),
      as_exp_map_increment(NULL, &mp, as_exp_str("sku-a"), as_exp_int(5), as_exp_bin_map("stock"))),
    as_exp_int(100)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapGetByKey(
    as.MapReturnType.VALUE,
    as.ExpTypeINT,
    as.ExpStringVal("sku-a"),
    as.ExpMapIncrement(
      as.DefaultMapPolicy(),
      as.ExpStringVal("sku-a"),
      as.ExpIntVal(5),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(100),
)

Expression exp = Exp.Build(
  Exp.EQ(
    MapExp.GetByKey(
      MapReturnType.VALUE,
      Exp.Type.INT,
      Exp.Val("sku-a"),
      MapExp.Increment(MapPolicy.Default, Exp.Val("sku-a"), Exp.Val(5), Exp.MapBin("stock"))),
    Exp.Val(100)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.eq(
  exp.maps.getByKey(
    exp.maps.increment(exp.binMap('stock'), exp.int(5), exp.str('sku-a'), null),
    exp.str('sku-a'),
    exp.type.INT,
    maps.returnType.VALUE,
  ),
  exp.int(100),
)

`map_put`

map_put(context, policy, key, value, bin)

Description

Add {key, value} element to bin. map_put does not create a new bin if the specified bin does not exist, unlike the put CDT Map operation, which does create a new bin if the specified bin does not exist.

Arguments

Name	Type
`context`	`library_specific`
`policy`	`library_specific`
`key`	`expr`
`value`	`expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map after putting {sku-a: 12} into stock.

import com.aerospike.client.cdt.MapPolicy;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(MapExp.put(MapPolicy.Default, Exp.val("sku-a"), Exp.val(12), Exp.mapBin("stock"))),
        Exp.val(2)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapPut, MapSize

exp = GT(MapSize(None, MapPut(None, None, "sku-a", 12, MapBin("stock"))), 2).compile()

as_map_policy mp;
as_map_policy_init(&mp);
as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_put(NULL, &mp, as_exp_str("sku-a"), as_exp_int(12), as_exp_bin_map("stock"))),
    as_exp_int(2)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapPut(
      as.DefaultMapPolicy(),
      as.ExpStringVal("sku-a"),
      as.ExpIntVal(12),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(2),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(MapExp.Put(MapPolicy.Default, Exp.Val("sku-a"), Exp.Val(12), Exp.MapBin("stock"))),
    Exp.Val(2)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp

const filterExp = exp.gt(
  exp.maps.size(exp.maps.put(exp.binMap('stock'), exp.int(12), exp.str('sku-a'), null)),
  exp.int(2),
)

`map_put_items`

map_put_items(context, policy, items, bin)

Description

Add elements in items to bin. map_put_items does not create a new bin if the specified bin does not exist, unlike the put_items CDT Map operation, which does create a new bin if the specified bin does not exist.

Arguments

Name	Type
`context`	`library_specific`
`policy`	`library_specific`
`items`	`map_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map after merging additional SKU entries into stock.

import com.aerospike.client.cdt.MapPolicy;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.putItems(
                MapPolicy.Default,
                Exp.val(java.util.Map.of("sku-b", 2, "sku-c", 3)),
                Exp.mapBin("stock"))),
        Exp.val(3)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapPutItems, MapSize

exp = GT(MapSize(None, MapPutItems(None, None, {"sku-b": 2, "sku-c": 3}, MapBin("stock"))), 3).compile()

as_map_policy mp;
as_map_policy_init(&mp);
as_hashmap hm;
as_hashmap_init(&hm, 2);
as_hashmap_set(&hm, (as_val*)as_string_new_strdup("sku-b"), (as_val*)as_integer_new(2));
as_hashmap_set(&hm, (as_val*)as_string_new_strdup("sku-c"), (as_val*)as_integer_new(3));
as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL, as_exp_map_put_items(NULL, &mp, as_exp_val(&hm), as_exp_bin_map("stock"))),
    as_exp_int(3)));
as_hashmap_destroy(&hm);

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
putMap := map[any]any{"sku-b": 2, "sku-c": 3}
_ = as.ExpGreater(
  as.ExpMapSize(as.ExpMapPutItems(as.DefaultMapPolicy(), as.ExpMapVal(putMap), as.ExpMapBin("stock"))),
  as.ExpIntVal(3),
)

using System.Collections.Generic;

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.PutItems(
        MapPolicy.Default,
        Exp.Val(new Dictionary<string, int> { { "sku-b", 2 }, { "sku-c", 3 } }),
        Exp.MapBin("stock"))),
    Exp.Val(3)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.putItems(exp.binMap('stock'), exp.map({ 'sku-b': 2, 'sku-c': 3 }), null),
  ),
  exp.int(3),
)

`map_remove_by_index`

map_remove_by_index(context, index, bin)

Description

Remove element at index.

Arguments

Name	Type
`context`	`library_specific`
`index`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing index 0.

import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(MapExp.size(MapExp.removeByIndex(Exp.val(0), Exp.mapBin("stock"))), Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByIndex, MapSize

exp = GT(MapSize(None, MapRemoveByIndex(None, 0, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(NULL, as_exp_map_remove_by_index(NULL, as_exp_int(0), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(as.ExpMapRemoveByIndex(as.ExpIntVal(0), as.ExpMapBin("stock"))),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(MapExp.Size(MapExp.RemoveByIndex(Exp.Val(0), Exp.MapBin("stock"))), Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp

const filterExp = exp.gt(
  exp.maps.size(exp.maps.removeByIndex(exp.binMap('stock'), exp.int(0))),
  exp.int(0),
)

`map_remove_by_index_range`

map_remove_by_index_range(context, index, count, bin)

Description

Remove count element at index.

Arguments

Name	Type
`context`	`library_specific`
`index`	`integer_expr`
`count`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing one entry at index 0.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByIndexRange(MapReturnType.NONE, Exp.val(0), Exp.val(1), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByIndexRange, MapSize

exp = GT(MapSize(None, MapRemoveByIndexRange(None, 0, 1, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_index_range(
        NULL, AS_MAP_RETURN_NONE, as_exp_int(0), as_exp_int(1), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByIndexRangeCount(
      as.MapReturnType.NONE,
      as.ExpIntVal(0),
      as.ExpIntVal(1),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByIndexRange(MapReturnType.NONE, Exp.Val(0), Exp.Val(1), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByIndexRange(exp.binMap('stock'), exp.int(1), exp.int(0), null, maps.returnType.NONE),
  ),
  exp.int(0),
)

`map_remove_by_index_range_to_end`

map_remove_by_index_range_to_end(context, index, bin)

Description

Remove all element at and after index.

Arguments

Name	Type
`context`	`library_specific`
`index`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing from index 1 to the end.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(MapExp.removeByIndexRange(MapReturnType.NONE, Exp.val(1), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByIndexRangeToEnd, MapSize

exp = GT(MapSize(None, MapRemoveByIndexRangeToEnd(None, 1, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_index_range_to_end(
        NULL, AS_MAP_RETURN_NONE, as_exp_int(1), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByIndexRange(as.MapReturnType.NONE, as.ExpIntVal(1), as.ExpMapBin("stock")),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(MapExp.RemoveByIndexRange(MapReturnType.NONE, Exp.Val(1), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByIndexRangeToEnd(exp.binMap('stock'), exp.int(1), null, maps.returnType.NONE),
  ),
  exp.int(0),
)

`map_remove_by_key`

map_remove_by_key(context, key, bin)

Description

Remove element with key key.

Arguments

Name	Type
`context`	`library_specific`
`key`	`expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing key sku-a.

import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.eq(MapExp.size(MapExp.removeByKey(Exp.val("sku-a"), Exp.mapBin("stock"))), Exp.val(2)));

from aerospike_helpers.expressions import Eq, MapBin
from aerospike_helpers.expressions.map import MapRemoveByKey, MapSize

exp = Eq(MapSize(None, MapRemoveByKey(None, "sku-a", MapBin("stock"))), 2).compile()

as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_size(NULL, as_exp_map_remove_by_key(NULL, as_exp_str("sku-a"), as_exp_bin_map("stock"))),
    as_exp_int(2)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapSize(as.ExpMapRemoveByKey(as.ExpStringVal("sku-a"), as.ExpMapBin("stock"))),
  as.ExpIntVal(2),
)

Expression exp = Exp.Build(
  Exp.EQ(MapExp.Size(MapExp.RemoveByKey(Exp.Val("sku-a"), Exp.MapBin("stock"))), Exp.Val(2)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp

const filterExp = exp.eq(exp.maps.size(exp.maps.removeByKey(exp.binMap('stock'), exp.str('sku-a'))), exp.int(2))

`map_remove_by_key_list`

map_remove_by_key_list(context, keys, bin)

Description

Remove all elements where key ∈ keys.

Arguments

Name	Type
`context`	`library_specific`
`keys`	`list_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing two keys.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

import java.util.Arrays;

Expression exp = Exp.build(
    Exp.eq(
        MapExp.size(
            MapExp.removeByKeyList(
                MapReturnType.NONE,
                Exp.val(Arrays.asList("sku-a", "sku-b")),
                Exp.mapBin("stock"))),
        Exp.val(1)));

from aerospike_helpers.expressions import Eq, MapBin
from aerospike_helpers.expressions.map import MapRemoveByKeyList, MapSize

exp = Eq(MapSize(None, MapRemoveByKeyList(None, ["sku-a", "sku-b"], MapBin("stock"))), 1).compile()

as_arraylist rk;
as_arraylist_init(&rk, 2, 2);
as_arraylist_append_str(&rk, "sku-a");
as_arraylist_append_str(&rk, "sku-b");
as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_key_list(NULL, AS_MAP_RETURN_NONE, as_exp_val(&rk), as_exp_bin_map("stock"))),
    as_exp_int(1)));
as_arraylist_destroy(&rk);

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapSize(
    as.ExpMapRemoveByKeyList(
      as.MapReturnType.NONE,
      as.ExpListVal(as.NewValue("sku-a"), as.NewValue("sku-b")),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(1),
)

using System.Collections.Generic;

Expression exp = Exp.Build(
  Exp.EQ(
    MapExp.Size(
      MapExp.RemoveByKeyList(MapReturnType.NONE, Exp.Val(new List<string> { "sku-a", "sku-b" }), Exp.MapBin("stock"))),
    Exp.Val(1)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.eq(
  exp.maps.size(
    exp.maps.removeByKeyList(exp.binMap('stock'), exp.list(['sku-a', 'sku-b']), null, maps.returnType.NONE),
  ),
  exp.int(1),
)

`map_remove_by_key_range`

map_remove_by_key_range(context, start, end, bin)

Description

Remove all elements with key k in interval start ≤ k < end.

Arguments

Name	Type
`context`	`library_specific`
`start`	`expr`
`end`	`expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing a key interval.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByKeyRange(
                MapReturnType.NONE, Exp.val("sku-a"), Exp.val("sku-z"), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByKeyRange, MapSize

exp = GT(MapSize(None, MapRemoveByKeyRange(None, "sku-a", "sku-z", MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_key_range(
        NULL, AS_MAP_RETURN_NONE, as_exp_str("sku-a"), as_exp_str("sku-z"), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByKeyRange(
      as.MapReturnType.NONE,
      as.ExpStringVal("sku-a"),
      as.ExpStringVal("sku-z"),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByKeyRange(MapReturnType.NONE, Exp.Val("sku-a"), Exp.Val("sku-z"), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByKeyRange(
      exp.binMap('stock'),
      exp.str('sku-z'),
      exp.str('sku-a'),
      null,
      maps.returnType.NONE,
    ),
  ),
  exp.int(0),
)

`map_remove_by_rank`

map_remove_by_rank(context, rank, bin)

Description

Remove all element with rank rank.

Arguments

Name	Type
`context`	`library_specific`
`rank`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing rank 0.

import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(MapExp.size(MapExp.removeByRank(Exp.val(0), Exp.mapBin("stock"))), Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByRank, MapSize

exp = GT(MapSize(None, MapRemoveByRank(None, 0, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(NULL, as_exp_map_remove_by_rank(NULL, as_exp_int(0), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(as.ExpMapRemoveByRank(as.ExpIntVal(0), as.ExpMapBin("stock"))),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(MapExp.Size(MapExp.RemoveByRank(Exp.Val(0), Exp.MapBin("stock"))), Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp

const filterExp = exp.gt(
  exp.maps.size(exp.maps.removeByRank(exp.binMap('stock'), exp.int(0))),
  exp.int(0),
)

`map_remove_by_rank_range`

map_remove_by_rank_range(context, rank, count, bin)

Description

Remove count element at rank.

Arguments

Name	Type
`context`	`library_specific`
`rank`	`integer_expr`
`count`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing two ranks starting at 0.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByRankRange(MapReturnType.NONE, Exp.val(0), Exp.val(2), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByRankRange, MapSize

exp = GT(MapSize(None, MapRemoveByRankRange(None, 0, 2, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_rank_range(
        NULL, AS_MAP_RETURN_NONE, as_exp_int(0), as_exp_int(2), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByRankRangeCount(
      as.MapReturnType.NONE,
      as.ExpIntVal(0),
      as.ExpIntVal(2),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByRankRange(MapReturnType.NONE, Exp.Val(0), Exp.Val(2), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByRankRange(exp.binMap('stock'), exp.int(2), exp.int(0), null, maps.returnType.NONE),
  ),
  exp.int(0),
)

`map_remove_by_rank_range_to_end`

map_remove_by_rank_range_to_end(context, rank, bin)

Description

Remove all elements at and after rank.

Arguments

Name	Type
`context`	`library_specific`
`rank`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing from rank 0 to the last rank.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(MapExp.removeByRankRange(MapReturnType.NONE, Exp.val(0), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByRankRangeToEnd, MapSize

exp = GT(MapSize(None, MapRemoveByRankRangeToEnd(None, 0, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_rank_range_to_end(
        NULL, AS_MAP_RETURN_NONE, as_exp_int(0), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByRankRange(as.MapReturnType.NONE, as.ExpIntVal(0), as.ExpMapBin("stock")),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(MapExp.RemoveByRankRange(MapReturnType.NONE, Exp.Val(0), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByRankRangeToEnd(exp.binMap('stock'), exp.int(0), null, maps.returnType.NONE),
  ),
  exp.int(0),
)

`map_remove_by_rel_index_range`

map_remove_by_rel_index_range(context, key, index, count, bin)

Description

Remove count elements at index relative to key.

Arguments

Name	Type
`context`	`library_specific`
`key`	`expr`
`index`	`integer_expr`
`count`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after a key-relative index remove with count.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByKeyRelativeIndexRange(
                MapReturnType.NONE, Exp.val("sku-a"), Exp.val(0), Exp.val(1), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByKeyRelIndexRange, MapSize

exp = GT(
    MapSize(None, MapRemoveByKeyRelIndexRange(None, "sku-a", 0, 1, MapBin("stock"))),
    0,
).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_key_rel_index_range(
        NULL, AS_MAP_RETURN_NONE, as_exp_str("sku-a"), as_exp_int(0), as_exp_int(1),
        as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByKeyRelativeIndexRangeCount(
      as.MapReturnType.NONE,
      as.ExpStringVal("sku-a"),
      as.ExpIntVal(0),
      as.ExpIntVal(1),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByKeyRelativeIndexRange(
        MapReturnType.NONE, Exp.Val("sku-a"), Exp.Val(0), Exp.Val(1), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByKeyRelIndexRange(
      exp.binMap('stock'),
      exp.int(1),
      exp.int(0),
      exp.str('sku-a'),
      null,
      maps.returnType.NONE,
    ),
  ),
  exp.int(0),
)

`map_remove_by_rel_index_range_to_end`

map_remove_by_rel_index_range_to_end(context, key, index, bin)

Description

Remove all elements at and after index relative to key.

Arguments

Name	Type
`context`	`library_specific`
`key`	`expr`
`index`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after a key-relative index remove to end.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByKeyRelativeIndexRange(
                MapReturnType.NONE, Exp.val("sku-a"), Exp.val(0), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByKeyRelIndexRangeToEnd, MapSize

exp = GT(MapSize(None, MapRemoveByKeyRelIndexRangeToEnd(None, "sku-a", 0, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_key_rel_index_range_to_end(
        NULL, AS_MAP_RETURN_NONE, as_exp_str("sku-a"), as_exp_int(0), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByKeyRelativeIndexRange(
      as.MapReturnType.NONE,
      as.ExpStringVal("sku-a"),
      as.ExpIntVal(0),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByKeyRelativeIndexRange(MapReturnType.NONE, Exp.Val("sku-a"), Exp.Val(0), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByKeyRelIndexRangeToEnd(
      exp.binMap('stock'),
      exp.int(0),
      exp.str('sku-a'),
      null,
      maps.returnType.NONE,
    ),
  ),
  exp.int(0),
)

`map_remove_by_rel_rank_range`

map_remove_by_rel_rank_range(context, value, rank, count, bin)

Description

Remove count elements at rank relative to value.

Arguments

Name	Type
`context`	`library_specific`
`value`	`expr`
`rank`	`integer_expr`
`count`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after a value-relative rank remove with count.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByValueRelativeRankRange(
                MapReturnType.NONE, Exp.val(5), Exp.val(0), Exp.val(2), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByValueRelRankRange, MapSize

exp = GT(MapSize(None, MapRemoveByValueRelRankRange(None, 5, 0, 2, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_value_rel_rank_range(
        NULL, AS_MAP_RETURN_NONE, as_exp_int(5), as_exp_int(0), as_exp_int(2), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByValueRelativeRankRangeCount(
      as.MapReturnType.NONE,
      as.ExpIntVal(5),
      as.ExpIntVal(0),
      as.ExpIntVal(2),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByValueRelativeRankRange(
        MapReturnType.NONE, Exp.Val(5), Exp.Val(0), Exp.Val(2), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByValueRelRankRange(
      exp.binMap('stock'),
      exp.int(2),
      exp.int(0),
      exp.int(5),
      null,
      maps.returnType.NONE,
    ),
  ),
  exp.int(0),
)

`map_remove_by_rel_rank_range_to_end`

map_remove_by_rel_rank_range_to_end(context, value, rank, bin)

Description

Remove all elements at and after rank relative to value.

Arguments

Name	Type
`context`	`library_specific`
`value`	`expr`
`rank`	`integer_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after a value-relative rank remove to end.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByValueRelativeRankRange(MapReturnType.NONE, Exp.val(5), Exp.val(0), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByValueRelRankRangeToEnd, MapSize

exp = GT(MapSize(None, MapRemoveByValueRelRankRangeToEnd(None, 5, 0, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_value_rel_rank_range_to_end(
        NULL, AS_MAP_RETURN_NONE, as_exp_int(5), as_exp_int(0), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByValueRelativeRankRange(
      as.MapReturnType.NONE,
      as.ExpIntVal(5),
      as.ExpIntVal(0),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByValueRelativeRankRange(MapReturnType.NONE, Exp.Val(5), Exp.Val(0), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByValueRelRankRangeToEnd(
      exp.binMap('stock'),
      exp.int(0),
      exp.int(5),
      null,
      maps.returnType.NONE,
    ),
  ),
  exp.int(0),
)

`map_remove_by_value`

map_remove_by_value(context, value, bin)

Description

Remove all element with value value.

Arguments

Name	Type
`context`	`library_specific`
`value`	`expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing by value 12.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(MapExp.size(MapExp.removeByValue(MapReturnType.NONE, Exp.val(12), Exp.mapBin("stock"))), Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByValue, MapSize

exp = GT(MapSize(None, MapRemoveByValue(None, 12, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL, as_exp_map_remove_by_value(NULL, AS_MAP_RETURN_NONE, as_exp_int(12), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByValue(as.MapReturnType.NONE, as.ExpIntVal(12), as.ExpMapBin("stock")),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(MapExp.RemoveByValue(MapReturnType.NONE, Exp.Val(12), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(exp.maps.removeByValue(exp.binMap('stock'), exp.int(12), null, maps.returnType.NONE)),
  exp.int(0),
)

`map_remove_by_value_list`

map_remove_by_value_list(context, values, bin)

Description

Remove all elements where value ∈ values.

Arguments

Name	Type
`context`	`library_specific`
`values`	`list_expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing by values 5 and 12.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

import java.util.Arrays;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByValueList(MapReturnType.NONE, Exp.val(Arrays.asList(5, 12)), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByValueList, MapSize

exp = GT(MapSize(None, MapRemoveByValueList(None, [5, 12], MapBin("stock"))), 0).compile()

as_arraylist rv;
as_arraylist_init(&rv, 2, 2);
as_arraylist_append_int64(&rv, 5);
as_arraylist_append_int64(&rv, 12);
as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_value_list(NULL, AS_MAP_RETURN_NONE, as_exp_val(&rv), as_exp_bin_map("stock"))),
    as_exp_int(0)));
as_arraylist_destroy(&rv);

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByValueList(
      as.MapReturnType.NONE,
      as.ExpListVal(as.NewValue(5), as.NewValue(12)),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

using System.Collections.Generic;

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByValueList(MapReturnType.NONE, Exp.Val(new List<long> { 5, 12 }), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByValueList(exp.binMap('stock'), exp.list([5, 12]), null, maps.returnType.NONE),
  ),
  exp.int(0),
)

`map_remove_by_value_range`

map_remove_by_value_range(context, start, end, bin)

Description

Remove all elements with value v in interval start ≤ v < end.

Arguments

Name	Type
`context`	`library_specific`
`start`	`expr`
`end`	`expr`
`bin`	`map_bin_expr`

Returns

map_bin

Introduced

5.2.0.4

Example

Hypothetical filter using the map size after removing values in [5, 20).

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.size(
            MapExp.removeByValueRange(MapReturnType.NONE, Exp.val(5), Exp.val(20), Exp.mapBin("stock"))),
        Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapRemoveByValueRange, MapSize

exp = GT(MapSize(None, MapRemoveByValueRange(None, 5, 20, MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(
      NULL,
      as_exp_map_remove_by_value_range(
        NULL, AS_MAP_RETURN_NONE, as_exp_int(5), as_exp_int(20), as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(
    as.ExpMapRemoveByValueRange(
      as.MapReturnType.NONE,
      as.ExpIntVal(5),
      as.ExpIntVal(20),
      as.ExpMapBin("stock"),
    ),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.Size(
      MapExp.RemoveByValueRange(MapReturnType.NONE, Exp.Val(5), Exp.Val(20), Exp.MapBin("stock"))),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.size(
    exp.maps.removeByValueRange(exp.binMap('stock'), exp.int(20), exp.int(5), null, maps.returnType.NONE),
  ),
  exp.int(0),
)

Read

`map_get_by_index`

map_get_by_index(type, context, result_type, index, bin)

Description

Get element at index.

Arguments

Name	Type
`type`	`integer_value`
`context`	`library_specific`
`result_type`	`integer_value`
`index`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the integer value at map index 0 equals 12.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.eq(
        MapExp.getByIndex(MapReturnType.VALUE, Exp.Type.INT, Exp.val(0), Exp.mapBin("stock")),
        Exp.val(12)));

import aerospike
from aerospike_helpers.expressions import Eq, MapBin, ResultType
from aerospike_helpers.expressions.map import MapGetByIndex

exp = Eq(
    MapGetByIndex(None, aerospike.MAP_RETURN_VALUE, ResultType.INTEGER, 0, MapBin("stock")),
    12,
).compile()

as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_get_by_index(
      NULL, AS_MAP_RETURN_VALUE, AS_EXP_TYPE_INT, as_exp_int(0), as_exp_bin_map("stock")),
    as_exp_int(12)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapGetByIndex(as.MapReturnType.VALUE, as.ExpTypeINT, as.ExpIntVal(0), as.ExpMapBin("stock")),
  as.ExpIntVal(12),
)

Expression exp = Exp.Build(
  Exp.EQ(
    MapExp.GetByIndex(MapReturnType.VALUE, Exp.Type.INT, Exp.Val(0), Exp.MapBin("stock")),
    Exp.Val(12)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.eq(
  exp.maps.getByIndex(exp.binMap('stock'), exp.int(0), exp.type.INT, maps.returnType.VALUE),
  exp.int(12),
)

`map_get_by_index_range`

map_get_by_index_range(context, result_type, index, count, bin)

Description

Get count elements at index.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`index`	`integer_expr`
`count`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where two entries exist starting at map index 0.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.eq(
        MapExp.getByIndexRange(MapReturnType.COUNT, Exp.val(0), Exp.val(2), Exp.mapBin("stock")),
        Exp.val(2)));

import aerospike
from aerospike_helpers.expressions import Eq, MapBin
from aerospike_helpers.expressions.map import MapGetByIndexRange

exp = Eq(
    MapGetByIndexRange(None, aerospike.MAP_RETURN_COUNT, 0, 2, MapBin("stock")),
    2,
).compile()

as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_get_by_index_range(
      NULL, AS_MAP_RETURN_COUNT, as_exp_int(0), as_exp_int(2), as_exp_bin_map("stock")),
    as_exp_int(2)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapGetByIndexRangeCount(
    as.MapReturnType.COUNT,
    as.ExpIntVal(0),
    as.ExpIntVal(2),
    as.ExpMapBin("stock"),
  ),
  as.ExpIntVal(2),
)

Expression exp = Exp.Build(
  Exp.EQ(
    MapExp.GetByIndexRange(MapReturnType.COUNT, Exp.Val(0), Exp.Val(2), Exp.MapBin("stock")),
    Exp.Val(2)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.eq(
  exp.maps.getByIndexRange(exp.binMap('stock'), exp.int(2), exp.int(0), maps.returnType.COUNT),
  exp.int(2),
)

`map_get_by_index_range_to_end`

map_get_by_index_range_to_end(context, result_type, index, bin)

Description

Get elements at and after index.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`index`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the count from index 1 to the end is positive.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(MapExp.getByIndexRange(MapReturnType.COUNT, Exp.val(1), Exp.mapBin("stock")), Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByIndexRangeToEnd

exp = GT(MapGetByIndexRangeToEnd(None, aerospike.MAP_RETURN_COUNT, 1, MapBin("stock")), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_index_range_to_end(
      NULL, AS_MAP_RETURN_COUNT, as_exp_int(1), as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByIndexRange(as.MapReturnType.COUNT, as.ExpIntVal(1), as.ExpMapBin("stock")),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByIndexRange(MapReturnType.COUNT, Exp.Val(1), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByIndexRangeToEnd(exp.binMap('stock'), exp.int(1), maps.returnType.COUNT),
  exp.int(0),
)

`map_get_by_key`

map_get_by_key(type, context, result_type, key, bin)

Description

Get element with key == key.

Arguments

Name	Type
`type`	`integer_value`
`context`	`library_specific`
`result_type`	`integer_value`
`key`	`expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the integer value at key sku-a in stock equals 12.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.eq(
        MapExp.getByKey(MapReturnType.VALUE, Exp.Type.INT, Exp.val("sku-a"), Exp.mapBin("stock")),
        Exp.val(12)));

import aerospike
from aerospike_helpers.expressions import Eq, MapBin, ResultType
from aerospike_helpers.expressions.map import MapGetByKey

exp = Eq(
    MapGetByKey(None, aerospike.MAP_RETURN_VALUE, ResultType.INTEGER, "sku-a", MapBin("stock")),
    12,
).compile()

as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_get_by_key(
      NULL, AS_MAP_RETURN_VALUE, AS_EXP_TYPE_INT, as_exp_str("sku-a"), as_exp_bin_map("stock")),
    as_exp_int(12)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapGetByKey(as.MapReturnType.VALUE, as.ExpTypeINT, as.ExpStringVal("sku-a"), as.ExpMapBin("stock")),
  as.ExpIntVal(12),
)

Expression exp = Exp.Build(
  Exp.EQ(
    MapExp.GetByKey(MapReturnType.VALUE, Exp.Type.INT, Exp.Val("sku-a"), Exp.MapBin("stock")),
    Exp.Val(12)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.eq(
  exp.maps.getByKey(exp.binMap('stock'), exp.str('sku-a'), exp.type.INT, maps.returnType.VALUE),
  exp.int(12),
)

`map_get_by_key_list`

map_get_by_key_list(context, result_type, keys, bin)

Description

Get all elements where key ∈ keys.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`keys`	`list_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the map has positive COUNT for keys sku-a and sku-b in stock.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

import java.util.Arrays;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.getByKeyList(
            MapReturnType.COUNT, Exp.val(Arrays.asList("sku-a", "sku-b")), Exp.mapBin("stock")),
        Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByKeyList

exp = GT(
    MapGetByKeyList(None, aerospike.MAP_RETURN_COUNT, ["sku-a", "sku-b"], MapBin("stock")),
    0,
).compile()

as_arraylist kl;
as_arraylist_init(&kl, 2, 2);
as_arraylist_append_str(&kl, "sku-a");
as_arraylist_append_str(&kl, "sku-b");
as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_key_list(
      NULL, AS_MAP_RETURN_COUNT, as_exp_val(&kl), as_exp_bin_map("stock")),
    as_exp_int(0)));
as_arraylist_destroy(&kl);

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByKeyList(
    as.MapReturnType.COUNT,
    as.ExpListVal(as.NewValue("sku-a"), as.NewValue("sku-b")),
    as.ExpMapBin("stock"),
  ),
  as.ExpIntVal(0),
)

using System.Collections.Generic;

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByKeyList(MapReturnType.COUNT, Exp.Val(new List<string> { "sku-a", "sku-b" }), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByKeyList(exp.binMap('stock'), exp.list(['sku-a', 'sku-b']), maps.returnType.COUNT),
  exp.int(0),
)

`map_get_by_key_range`

map_get_by_key_range(context, result_type, start, end, bin)

Description

Get all elements with key k in interval start ≤ k < end.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`start`	`expr`
`end`	`expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the count of map entries with keys less than sku-z is positive.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.getByKeyRange(MapReturnType.COUNT, Exp.val((String) null), Exp.val("sku-z"), Exp.mapBin("stock")),
        Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByKeyRange

exp = GT(
    MapGetByKeyRange(None, aerospike.MAP_RETURN_COUNT, None, "sku-z", MapBin("stock")),
    0,
).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_key_range(
      NULL, AS_MAP_RETURN_COUNT, as_exp_nil(), as_exp_str("sku-z"), as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByKeyRange(as.MapReturnType.COUNT, nil, as.ExpStringVal("sku-z"), as.ExpMapBin("stock")),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByKeyRange(MapReturnType.COUNT, null, Exp.Val("sku-z"), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByKeyRange(exp.binMap('stock'), exp.str('sku-z'), exp.nil(), maps.returnType.COUNT),
  exp.int(0),
)

`map_get_by_rank`

map_get_by_rank(type, context, result_type, rank, bin)

Description

Get element at rank.

Arguments

Name	Type
`type`	`integer_value`
`context`	`library_specific`
`result_type`	`integer_value`
`rank`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the lowest-ranked value equals 5.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.eq(
        MapExp.getByRank(MapReturnType.VALUE, Exp.Type.INT, Exp.val(0), Exp.mapBin("stock")),
        Exp.val(5)));

import aerospike
from aerospike_helpers.expressions import Eq, MapBin, ResultType
from aerospike_helpers.expressions.map import MapGetByRank

exp = Eq(
    MapGetByRank(None, aerospike.MAP_RETURN_VALUE, ResultType.INTEGER, 0, MapBin("stock")),
    5,
).compile()

as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_get_by_rank(
      NULL, AS_MAP_RETURN_VALUE, AS_EXP_TYPE_INT, as_exp_int(0), as_exp_bin_map("stock")),
    as_exp_int(5)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapGetByRank(as.MapReturnType.VALUE, as.ExpTypeINT, as.ExpIntVal(0), as.ExpMapBin("stock")),
  as.ExpIntVal(5),
)

Expression exp = Exp.Build(
  Exp.EQ(
    MapExp.GetByRank(MapReturnType.VALUE, Exp.Type.INT, Exp.Val(0), Exp.MapBin("stock")),
    Exp.Val(5)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.eq(
  exp.maps.getByRank(exp.binMap('stock'), exp.int(0), exp.type.INT, maps.returnType.VALUE),
  exp.int(5),
)

`map_get_by_rank_range`

map_get_by_rank_range(context, result_type, rank, count, bin)

Description

Get count element at rank.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`rank`	`integer_expr`
`count`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where exactly two entries are selected starting at rank 0.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.eq(
        MapExp.getByRankRange(MapReturnType.COUNT, Exp.val(0), Exp.val(2), Exp.mapBin("stock")),
        Exp.val(2)));

import aerospike
from aerospike_helpers.expressions import Eq, MapBin
from aerospike_helpers.expressions.map import MapGetByRankRange

exp = Eq(
    MapGetByRankRange(None, aerospike.MAP_RETURN_COUNT, 0, 2, MapBin("stock")),
    2,
).compile()

as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_get_by_rank_range(
      NULL, AS_MAP_RETURN_COUNT, as_exp_int(0), as_exp_int(2), as_exp_bin_map("stock")),
    as_exp_int(2)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapGetByRankRangeCount(
    as.MapReturnType.COUNT,
    as.ExpIntVal(0),
    as.ExpIntVal(2),
    as.ExpMapBin("stock"),
  ),
  as.ExpIntVal(2),
)

Expression exp = Exp.Build(
  Exp.EQ(
    MapExp.GetByRankRange(MapReturnType.COUNT, Exp.Val(0), Exp.Val(2), Exp.MapBin("stock")),
    Exp.Val(2)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.eq(
  exp.maps.getByRankRange(exp.binMap('stock'), exp.int(2), exp.int(0), maps.returnType.COUNT),
  exp.int(2),
)

`map_get_by_rank_range_to_end`

map_get_by_rank_range_to_end(context, result_type, rank, bin)

Description

Get all elements at and after rank.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`rank`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the count from rank 0 to the last rank is positive.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(MapExp.getByRankRange(MapReturnType.COUNT, Exp.val(0), Exp.mapBin("stock")), Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByRankRangeToEnd

exp = GT(MapGetByRankRangeToEnd(None, aerospike.MAP_RETURN_COUNT, 0, MapBin("stock")), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_rank_range_to_end(
      NULL, AS_MAP_RETURN_COUNT, as_exp_int(0), as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByRankRange(as.MapReturnType.COUNT, as.ExpIntVal(0), as.ExpMapBin("stock")),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByRankRange(MapReturnType.COUNT, Exp.Val(0), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByRankRangeToEnd(exp.binMap('stock'), exp.int(0), maps.returnType.COUNT),
  exp.int(0),
)

`map_get_by_rel_index_range`

map_get_by_rel_index_range(context, result_type, key, index, count_expr, bin)

Description

Get count elements at index relative to key.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`key`	`expr`
`index`	`integer_expr`
`count_expr`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where exactly one entry is selected starting at index 0 relative to key sku-a.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.eq(
        MapExp.getByKeyRelativeIndexRange(
            MapReturnType.COUNT, Exp.val("sku-a"), Exp.val(0), Exp.val(1), Exp.mapBin("stock")),
        Exp.val(1)));

import aerospike
from aerospike_helpers.expressions import Eq, MapBin
from aerospike_helpers.expressions.map import MapGetByKeyRelIndexRange

exp = Eq(
    MapGetByKeyRelIndexRange(None, aerospike.MAP_RETURN_COUNT, "sku-a", 0, 1, MapBin("stock")),
    1,
).compile()

as_exp_build(predexp,
  as_exp_cmp_eq(
    as_exp_map_get_by_key_rel_index_range(
      NULL, AS_MAP_RETURN_COUNT, as_exp_str("sku-a"), as_exp_int(0), as_exp_int(1),
      as_exp_bin_map("stock")),
    as_exp_int(1)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpEq(
  as.ExpMapGetByKeyRelativeIndexRangeCount(
    as.MapReturnType.COUNT,
    as.ExpStringVal("sku-a"),
    as.ExpIntVal(0),
    as.ExpIntVal(1),
    as.ExpMapBin("stock"),
  ),
  as.ExpIntVal(1),
)

Expression exp = Exp.Build(
  Exp.EQ(
    MapExp.GetByKeyRelativeIndexRange(MapReturnType.COUNT, Exp.Val("sku-a"), Exp.Val(0), Exp.Val(1), Exp.MapBin("stock")),
    Exp.Val(1)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.eq(
  exp.maps.getByKeyRelIndexRange(
    exp.binMap('stock'),
    exp.int(1),
    exp.int(0),
    exp.str('sku-a'),
    maps.returnType.COUNT,
  ),
  exp.int(1),
)

`map_get_by_rel_index_range_to_end`

map_get_by_rel_index_range_to_end(context, result_type, key, index_expr, bin)

Description

Get all elements at and after index relative to key.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`key`	`expr`
`index_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the COUNT of entries from index 0 relative to key sku-a is positive.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.getByKeyRelativeIndexRange(
            MapReturnType.COUNT, Exp.val("sku-a"), Exp.val(0), Exp.mapBin("stock")),
        Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByKeyRelIndexRangeToEnd

exp = GT(
    MapGetByKeyRelIndexRangeToEnd(None, aerospike.MAP_RETURN_COUNT, "sku-a", 0, MapBin("stock")),
    0,
).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_key_rel_index_range_to_end(
      NULL, AS_MAP_RETURN_COUNT, as_exp_str("sku-a"), as_exp_int(0), as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByKeyRelativeIndexRange(
    as.MapReturnType.COUNT,
    as.ExpStringVal("sku-a"),
    as.ExpIntVal(0),
    as.ExpMapBin("stock"),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByKeyRelativeIndexRange(MapReturnType.COUNT, Exp.Val("sku-a"), Exp.Val(0), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByKeyRelIndexRangeToEnd(
    exp.binMap('stock'),
    exp.int(0),
    exp.str('sku-a'),
    maps.returnType.COUNT,
  ),
  exp.int(0),
)

`map_get_by_rel_rank_range`

map_get_by_rel_rank_range(context, result_type, value, rank, count, bin)

Description

Get count elements at rank relative to value.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`value`	`expr`
`rank`	`integer_expr`
`count`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where bounded relative-rank selection from value 5 has positive COUNT.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.getByValueRelativeRankRange(
            MapReturnType.COUNT, Exp.val(5), Exp.val(0), Exp.val(2), Exp.mapBin("stock")),
        Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByValueRelRankRange

exp = GT(
    MapGetByValueRelRankRange(None, aerospike.MAP_RETURN_COUNT, 5, 0, 2, MapBin("stock")),
    0,
).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_value_rel_rank_range(
      NULL, AS_MAP_RETURN_COUNT, as_exp_int(5), as_exp_int(0), as_exp_int(2), as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByValueRelativeRankRangeCount(
    as.MapReturnType.COUNT,
    as.ExpIntVal(5),
    as.ExpIntVal(0),
    as.ExpIntVal(2),
    as.ExpMapBin("stock"),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByValueRelativeRankRange(
      MapReturnType.COUNT, Exp.Val(5), Exp.Val(0), Exp.Val(2), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByValueRelRankRange(
    exp.binMap('stock'),
    exp.int(2),
    exp.int(0),
    exp.int(5),
    maps.returnType.COUNT,
  ),
  exp.int(0),
)

`map_get_by_rel_rank_range_to_end`

map_get_by_rel_rank_range_to_end(context, result_type, value, rank, bin)

Description

Get all elements at and after rank relative to value.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`value`	`expr`
`rank`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where relative rank selection from value 5 has positive COUNT.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.getByValueRelativeRankRange(
            MapReturnType.COUNT, Exp.val(5), Exp.val(0), Exp.mapBin("stock")),
        Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByValueRelRankRangeToEnd

exp = GT(
    MapGetByValueRelRankRangeToEnd(None, aerospike.MAP_RETURN_COUNT, 5, 0, MapBin("stock")),
    0,
).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_value_rel_rank_range_to_end(
      NULL, AS_MAP_RETURN_COUNT, as_exp_int(5), as_exp_int(0), as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByValueRelativeRankRange(
    as.MapReturnType.COUNT,
    as.ExpIntVal(5),
    as.ExpIntVal(0),
    as.ExpMapBin("stock"),
  ),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByValueRelativeRankRange(MapReturnType.COUNT, Exp.Val(5), Exp.Val(0), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByValueRelRankRangeToEnd(
    exp.binMap('stock'),
    exp.int(0),
    exp.int(5),
    maps.returnType.COUNT,
  ),
  exp.int(0),
)

`map_get_by_value`

map_get_by_value(context, result_type, value, bin)

Description

Get all elements where value == value.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`value`	`expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the count of map entries with value 12 is positive.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(MapExp.getByValue(MapReturnType.COUNT, Exp.val(12), Exp.mapBin("stock")), Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByValue

exp = GT(MapGetByValue(None, aerospike.MAP_RETURN_COUNT, 12, MapBin("stock")), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_value(NULL, AS_MAP_RETURN_COUNT, as_exp_int(12), as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByValue(as.MapReturnType.COUNT, as.ExpIntVal(12), as.ExpMapBin("stock")),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(MapExp.GetByValue(MapReturnType.COUNT, Exp.Val(12), Exp.MapBin("stock")), Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByValue(exp.binMap('stock'), exp.int(12), maps.returnType.COUNT),
  exp.int(0),
)

`map_get_by_value_list`

map_get_by_value_list(context, result_type, values, bin)

Description

Get all elements where value ∈ values.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`values`	`list_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the count of entries with values 5 and 12 is positive.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

import java.util.Arrays;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.getByValueList(MapReturnType.COUNT, Exp.val(Arrays.asList(5, 12)), Exp.mapBin("stock")),
        Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByValueList

exp = GT(
    MapGetByValueList(None, aerospike.MAP_RETURN_COUNT, [5, 12], MapBin("stock")),
    0,
).compile()

as_arraylist vl;
as_arraylist_init(&vl, 2, 2);
as_arraylist_append_int64(&vl, 5);
as_arraylist_append_int64(&vl, 12);
as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_value_list(
      NULL, AS_MAP_RETURN_COUNT, as_exp_val(&vl), as_exp_bin_map("stock")),
    as_exp_int(0)));
as_arraylist_destroy(&vl);

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByValueList(
    as.MapReturnType.COUNT,
    as.ExpListVal(as.NewValue(5), as.NewValue(12)),
    as.ExpMapBin("stock"),
  ),
  as.ExpIntVal(0),
)

using System.Collections.Generic;

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByValueList(MapReturnType.COUNT, Exp.Val(new List<long> { 5, 12 }), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByValueList(exp.binMap('stock'), exp.list([5, 12]), maps.returnType.COUNT),
  exp.int(0),
)

`map_get_by_value_range`

map_get_by_value_range(context, result_type, start, end, bin)

Description

Get all elements with value v in interval start ≤ v < end.

Arguments

Name	Type
`context`	`library_specific`
`result_type`	`integer_value`
`start`	`integer_expr`
`end`	`integer_expr`
`bin`	`map_bin_expr`

Introduced

5.2.0.4

Example

Filter where the count of values in [5, 50) in stock is positive.

import com.aerospike.client.cdt.MapReturnType;
import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
    Exp.gt(
        MapExp.getByValueRange(MapReturnType.COUNT, Exp.val(5), Exp.val(50), Exp.mapBin("stock")),
        Exp.val(0)));

import aerospike
from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetByValueRange

exp = GT(MapGetByValueRange(None, aerospike.MAP_RETURN_COUNT, 5, 50, MapBin("stock")), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_get_by_value_range(
      NULL, AS_MAP_RETURN_COUNT, as_exp_int(5), as_exp_int(50), as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapGetByValueRange(as.MapReturnType.COUNT, as.ExpIntVal(5), as.ExpIntVal(50), as.ExpMapBin("stock")),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    MapExp.GetByValueRange(MapReturnType.COUNT, Exp.Val(5), Exp.Val(50), Exp.MapBin("stock")),
    Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp
const maps = Aerospike.maps

const filterExp = exp.gt(
  exp.maps.getByValueRange(exp.binMap('stock'), exp.int(50), exp.int(5), maps.returnType.COUNT),
  exp.int(0),
)

`map_keys`

map_keys(bin)

Description

Extract all keys from a map as a list. Unlike the MapExp / CDT map read operations, this is a standalone expression (Exp class) that takes no context or return_type parameter.

Arguments

Name	Type
`bin`	`map_bin_expr`

Returns

list_value

Introduced

8.1.2

Example

Get the keys of map bin stock as a list, then check its list_size is greater than 0.

import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.ListExp;

Expression exp = Exp.build(
  Exp.gt(
    ListExp.size(Exp.mapKeysIn(Exp.mapBin("stock"))),
    Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetKeys
from aerospike_helpers.expressions.list import ListSize

exp = GT(ListSize(None, MapGetKeys(MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_list_size(NULL, as_exp_map_keys(as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpListSize(as.ExpMapKeys(as.ExpMapBin("stock"))),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    ListExp.Size(Exp.MapKeysIn(Exp.MapBin("stock"))),
    Exp.Val(0)));

`map_size`

map_size(context, bin)

Description

Get number of items in the map.

Arguments

Name	Type
`context`	`library_specific`
`bin`	`map_bin_expr`

Returns

integer_bin

Introduced

5.2.0.4

Example

Filter records whose map bin stock is non-empty (same pattern as bin_map with size).

import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.MapExp;

Expression exp = Exp.build(
  Exp.gt(MapExp.size(Exp.mapBin("stock")), Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapSize

exp = GT(MapSize(None, MapBin("stock")), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_map_size(NULL, as_exp_bin_map("stock")),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpMapSize(as.ExpMapBin("stock")),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(MapExp.Size(Exp.MapBin("stock")), Exp.Val(0)));

const Aerospike = require('aerospike')
const exp = Aerospike.exp

const filterExp = exp.gt(
  exp.maps.size(exp.binMap('stock')),
  exp.int(0),
)

`map_values`

map_values(bin)

Description

Extract all values from a map as a list. Unlike the MapExp / CDT map read operations, this is a standalone expression (Exp class) that takes no context or return_type parameter.

Arguments

Name	Type
`bin`	`map_bin_expr`

Returns

list_value

Introduced

8.1.2

Example

Get the values of map bin stock as a list, then check its list_size is greater than 0.

import com.aerospike.client.exp.Expression;
import com.aerospike.client.exp.Exp;
import com.aerospike.client.exp.ListExp;

Expression exp = Exp.build(
  Exp.gt(
    ListExp.size(Exp.mapValuesIn(Exp.mapBin("stock"))),
    Exp.val(0)));

from aerospike_helpers.expressions import GT, MapBin
from aerospike_helpers.expressions.map import MapGetValues
from aerospike_helpers.expressions.list import ListSize

exp = GT(ListSize(None, MapGetValues(MapBin("stock"))), 0).compile()

as_exp_build(predexp,
  as_exp_cmp_gt(
    as_exp_list_size(NULL, as_exp_map_values(as_exp_bin_map("stock"))),
    as_exp_int(0)));

// Requires: import as "github.com/aerospike/aerospike-client-go/v6"
_ = as.ExpGreater(
  as.ExpListSize(as.ExpMapValues(as.ExpMapBin("stock"))),
  as.ExpIntVal(0),
)

Expression exp = Exp.Build(
  Exp.GT(
    ListExp.Size(Exp.MapValuesIn(Exp.MapBin("stock"))),
    Exp.Val(0)));