Skip to content

List operations

For the complete documentation index see: llms.txt

All documentation pages available in markdown.

List operations read, update, and remove elements in list-type bins directly on the server.

These operations have expression counterparts, which evaluate to a value instead of writing it. See List expressions for the set, and Operations and expressions for which to reach for.

List policy

The list policy defines the order and write behavior for a list.

List order

The list order is set in the list policy and determines the list subtype:

  • Unordered (default) - maintains insertion order. New elements are appended to the end.
  • Ordered - maintains sorted (rank) order. Elements are sorted on each write.

Use set_order() to convert between order types.

See List performance for the operational complexity of each order type.

Persisting the list index

For large ordered lists with a high read-to-write ratio, rebuilding the offset index on every access can consume significant CPU. Setting persistIndex to true in set_order() or create() stores the offset index on disk alongside the list itself, so subsequent operations load it directly instead of rebuilding it.

Once set, both the order and persist-index flags are preserved across all subsequent list operations (append, insert, remove, etc.) until changed by another set_order() call.

The persist-index flag applies only to top-level lists. For nested lists the flag is silently ignored.

See column (3) in the List performance table for the performance impact.

Write flags

FlagDescription
MODIFY_DEFAULTDefault: not bound by list size; accepts duplicate elements; throws error on failure
ADD_UNIQUEOnly add elements if they do not already exist in the list
INSERT_BOUNDEDDo not insert past index N, where N is the element count
NO_FAILNo-op instead of fail if a policy violation occurred, such as ADD_UNIQUE or INSERT_BOUNDED
DO_PARTIALWhen used with NO_FAIL, add elements that did not violate a policy

Write flags can be combined using bitwise OR. For example, ADD_UNIQUE | NO_FAIL | DO_PARTIAL adds only unique elements, skips duplicates without failing, and commits the non-duplicate elements.

Context

Context TypeDescription
LIST_INDEXFinds an element in a List by index. A negative index is a lookup performed in reverse from the end of the list. If it is out of bounds, a parameter error is returned.
LIST_RANKFinds an element in a List by rank. A negative rank is a lookup performed in reverse from the highest ranked.
LIST_VALUEFinds an element in a List by value.
LIST_INDEX_CREATEFinds an element in a List by index. Creates the element if it does not exist.

The context is a list of element selectors describing a path to the nested list element where the operation should be applied. Without a context it is assumed that the operation occurs at the top level of the list.

Return types

Return TypeDescription
VALUEThe value of the element (in single result operations) or elements (in multi result operations)
NONENothing is returned. It speeds up remove operations by not constructing a reply
COUNTNumber of elements returned
INDEXIndex position of the element, from 0 (first) to N-1 (last)
REVERSE_INDEXReverse index position of the element, from 0 (last) to N-1 (first)
RANKValue order of the element, with 0 being the smallest
REVERSE_RANKReverse rank order of the element, with 0 being the largest value
INVERTEDInvert meaning of list command and return values. Combine with another return type using bitwise OR, such as `COUNT
EXISTSReturns a boolean true if any elements match the criteria. For example, get_all_by_value with EXISTS returns true if the value is in the list.

Examples

  • Remove the last 3 elements: remove_by_index_range(-3, 3, NONE)
  • Remove all but the last 3 elements: remove_by_index_range(-3, 3, NONE | INVERTED)
  • Keep only the last 3 elements and return the count of removed elements: remove_by_index_range(-3, 3, COUNT | INVERTED)

Availability

EXISTS available since 6.1.0.

Modify operations

append_items 

append_items(policy, bin_name, items[, context])
Description

Creates a list bin with a specified order, if the bin does not exist. Adds the items to the list. In an UNORDERED list the items are appended to the end of the list. In an ORDERED list the items are inserted by value order.

Arguments
NameTypeDescription
policyList policy

Ordering and write flags for the operation. See Write flags. The ordering attribute takes effect only when this operation creates the list; on a list that already exists it is ignored.

bin_namestring

Name of the bin to operate on.

itemslist

Elements to append, as a list.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

The element count due to the operation, in the ‘bins’ part of the record under the bin name.

Expression form

list_append_items

Order

A list newly created with append_items can be declared UNORDERED (default) or ORDERED using the list order attribute of the list policy. Once a list is created its order can only be modified with set_order.

Performance

The worst-case performance of append_items on an unordered list is 𝓞(M), and 𝓞((M+N) log (M+N)) on an ordered list, where M is the number of items to append and N is the number of items already in the list.

Code sample 
// scores = [10, 20, 30]


try (RecordStream rs = session.upsert(key)
    .bin("scores").listAppendItems(List.of(40, 50))
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 5 (new list size)
}
// scores == [10, 20, 30, 40, 50]

append 

append(policy, bin_name, value[, context])
Description

Creates a list bin with a specified order, if the bin does not exist. Adds a value to the list. In an UNORDERED list the value is appended to the end of the list. In an ORDERED list the value is inserted by value order.

Arguments
NameTypeDescription
policyList policy

Ordering and write flags for the operation. See Write flags. The ordering attribute takes effect only when this operation creates the list; on a list that already exists it is ignored.

bin_namestring

Name of the bin to operate on.

valueany

Element to append to the list.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

The element count due to the operation, in the ‘bins’ part of the record under the bin name.

Expression form

list_append

Order

A list newly created with append can be declared UNORDERED (default) or ORDERED using the list order attribute of the list policy. Once a list is created its order can only be modified with set_order.

Performance

The worst-case performance of append() on an unordered list is 𝓞(N).

Code sample 
// scores = [10, 20, 30]


try (RecordStream rs = session.upsert(key)
    .bin("scores").listAppend(40)
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 4 (new list size)
}
// scores == [10, 20, 30, 40]

clear 

clear(bin_name[, context])
Description

Clears a list, optionally at a given subcontext.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

null

Expression form

list_clear

Performance

The worst-case performance of clearing a list is 𝓞(1).

Code sample 
// scores = [10, 20, 30, 40, 50]


try (RecordStream rs = session.upsert(key)
    .bin("scores").listClear()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// scores == []

increment 

increment(policy, bin_name, index, delta[, context])
Description

Creates an unordered list bin if the bin does not exist. In an UNORDERED list, increment() initializes or increments a numeric value at the specified list index. In an ORDERED list, increments a numeric value at a specific rank, given by the index argument.

By default the index can be any number, and NIL values will be added as padding to the left of the new element, as needed. Using the INSERT_BOUNDED policy, a developer can limit this behavior, and only allow for an element to be incremented at an index value between 0 and the size of the list.

Increment delta values can be either float or integer. An integer delta value will be converted into a float if the server-side type is a float. A float delta-value will be converted and truncated into an integer if the server-side value is an integer.

Arguments
NameTypeDescription
policyList policy

Ordering and write flags for the operation. See Write flags. The ordering attribute takes effect only when this operation creates the list; on a list that already exists it is ignored.

bin_namestring

Name of the bin to operate on.

indexinteger

Zero-based position of the element to increment.

deltainteger or float

Amount to add. A negative value subtracts.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

The new value after the increment, in the ‘bins’ part of the record under the bin name.

Expression form

list_increment

Order

A list newly created with increment is always unordered. Once a list is created its order can only be modified with set_order.

Performance

The worst-case performance of increment() on an unordered list is 𝓞(N).

Code sample 
// scores = [10, 20, 30]


try (RecordStream rs = session.upsert(key)
    .bin("scores").listIncrement(1, 5)
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 25 (new value at index 1)
}
// scores == [10, 25, 30]

insert 

insert(policy, bin_name, index, value[, context])
Description

Creates an unordered list bin, if the bin does not exist. Inserts a value into the list at the specified index, and shifts elements with a higher index to the right of the new element.

By default the index can be any number, and NIL values will be added as padding to the left of the new element, as needed. Using the INSERT_BOUNDED policy, a developer can limit this behavior, and only allow for an element to be inserted at an index value between 0 and the size of the list.

you cannot insert into an ordered list, only append or append_items to one.

Arguments
NameTypeDescription
policyList policy

Ordering and write flags for the operation. See Write flags. The ordering attribute takes effect only when this operation creates the list; on a list that already exists it is ignored.

bin_namestring

Name of the bin to operate on.

indexinteger

Zero-based position, 0 being the first element. A negative index counts back from the end.

valueany

Element to insert at index.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

The element count due to the operation, in the ‘bins’ part of the record under the bin name.

Expression form

list_insert, list_insert_items

Order

A list newly created with insert is always unordered. Once a list is created its order can only be modified with set_order.

Performance

The worst-case performance of inserting an item at the head of a list (at its 0th index) is 𝓞(1). At any other index it is 𝓞(N).

Code sample 
// scores = [10, 30, 40]


try (RecordStream rs = session.upsert(key)
    .bin("scores").listInsert(1, 20)
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 4 (new list size)
}
// scores == [10, 20, 30, 40]

remove_all_by_value_list 

remove_by_value_list(bin_name, values, result_type[, context])
Description

Removes all the elements in the list matching one of the specified values. The INVERTED flag may be used to remove the elements not matching the specified values.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

valueslist

Values to match, as a list. Every element equal to any of them is selected.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The NONE return type will execute faster because no reply is constructed for the operation. The elements returned by other return types may not be in index order.

Expression form

list_remove_by_value_list

Order

Whether the list is unordered or ordered, remove_all_by_value_list will return the same elements, based on the ordering rules. The performance of ‘by value’ operations is better on an ordered list than an unordered one.

Performance

The worst-case performance of removing elements by a value list is 𝓞((M+N) log M) for an ordered list with a persisted index, 𝓞((M+N) log M + N) for an ordered list without a persisted index, or for an unordered list, where M is the number of items in the parameter list and N is the number of items already in the list.

Examples
Trivial example

Remove scalar values from the list matching one of several specified values. See the code sample below.

Matching tuples with wildcard

See the example given for remove_all_by_value.

In a list of mostly ordered pairs, we could remove all the tuples matching the patterns [v1, *] and [v2, *].

The wildcard matches any sequence of elements to the end of the tuple. In this example, this means matching any tuple whose first position is “v1” or “v2”, and whose size is two or more elements.

The wildcard has different language-specific constructs, such as aerospike.CDTWildcard() in the Python client and Value.WILDCARD in the Java client.

Code sample 
// Trivial example
// l = [1, 2, 3, 4, 3, 2, 1]


try (RecordStream rs = session.upsert(key)
    .bin("l").onListValueList(List.of(2, 3)).removeAnd().count()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 4
}
// l == [1, 4, 1]


// Matching tuples with wildcard
// l = [["v1", 1], ["v2", 2], ["v3", 3], ["v2", 4], ["v1", 5]]


try (RecordStream rs = session.upsert(key)
    .bin("l").onListValueList(List.of(
        List.of("v1", SpecialValue.WILDCARD),
        List.of("v2", SpecialValue.WILDCARD))).remove()
    .bin("l").get()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// l == [["v3", 3]]

remove_all_by_value 

remove_by_value(bin_name, value, result_type[, context])
Description

Removes all the elements in the list matching value. The INVERTED flag may be used to remove the elements not matching the specified value.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

valueany

Value to match. Every element equal to it is selected.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The NONE return type will execute faster because no reply is constructed for the operation. The elements returned by other return types may not be in index order.

Expression form

list_remove_by_value

Order

Whether the list is unordered or ordered, remove_all_by_value will return the same elements, based on the ordering rules. The performance of ‘by value’ operations is better on an ordered list than an unordered one.

Performance

The worst-case performance of removing elements by value is 𝓞(log N + M) for an ordered list with a persisted index, 𝓞(log N + N) for an ordered list without a persisted index, and 𝓞(N + M) for an unordered list, where M is the number of items in the parameter list and N is the number of items already in the list.

Examples
Trivial example

Remove scalar values from the list. See the code sample below.

Matching tuples with wildcard

It is common to model complex data in Aerospike as a list of tuples, each element a list, where the index order carries meaning. For an example, see Aerospike Modeling: IoT Sensors.

In a list of mostly ordered pairs, we could remove a specific kind of element, such as all the tuples where the 0th position is “v2”, by using a wildcard (typically stylized as a * in documentation).

The wildcard matches any sequence of elements to the end of the tuple. In this example, this means matching any tuple whose first position is “v2”, and whose size is two or more elements.

The wildcard has different language-specific constructs, such as aerospike.CDTWildcard() in the Python client and Value.WILDCARD in the Java client.

Code sample 
// Trivial example
// l = [1, 2, 1, 2]


try (RecordStream rs = session.upsert(key)
    .bin("l").onListValue(2).removeAnd().count()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 2
}


// Matching tuples with wildcard
// l = [["v1", 1], ["v2", 2], ["v1", 3], ["v2", 4, {"a": 1}]]


try (RecordStream rs = session.upsert(key)
    .bin("l").onListValue(List.of("v2", SpecialValue.WILDCARD))
        .removeAnd().getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns [["v2", 2], ["v2", 4, {"a": 1}]]
}

remove_by_index_range 

remove_by_index_range(bin_name, index[, count], result_type[, context])
Description

Removes a range of count elements starting at a specified list index. The INVERTED flag may be used to remove the elements not in a specified range.

The index and count can be any number, but the result may be an empty list if the specified range contains no elements.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

indexinteger

Zero-based position, 0 being the first element. A negative index counts back from the end.

countinteger

Number of elements to select. Optional; defaults to the rest of the collection.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The NONE return type will execute faster because no reply is constructed for the operation. The elements returned by other return types may not be in index order.

Expression form

list_remove_by_index_range, list_remove_by_index_range_to_end

Performance

The worst-case performance of removing elements by index range is 𝓞(M) for an ordered list with a persisted index, and 𝓞(N + M) for an ordered list without a persisted index or an unordered list, where M is the element count of the range, and N is the element count of the list. Requesting a RANK return type on an unordered list adds 𝓞(L*N). See List performance.

Examples
Example

For [1, 3, 3, 7, 0] with return type NONE a range starting at index 2 and containing 3 elements removes [3, 7, 0], while the INVERTED | NONE of the same range removes [1, 3].

Code sample 
// l = [1, 3, 3, 7, 0]


try (RecordStream rs = session.upsert(key)
    .bin("l").onListIndexRange(2, 3).remove()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// l == [1, 3]


// INVERTED: remove everything outside the range
// l = [1, 3, 3, 7, 0]


try (RecordStream rs = session.upsert(key)
    .bin("l").onListIndexRange(2, 3).removeAllOthers()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// l == [3, 7, 0]

remove_by_index 

remove_by_index(bin_name, index, result_type[, context])
Description

Removes the element at the specified list index. The index must be a number between 0 and N-1, where N is the length of the list. The index can also be a negative number, with -1 being the last element by index position.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

indexinteger

Zero-based position, 0 being the first element. A negative index counts back from the end.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero or one value, based on the return type. The NONE return type will execute faster because no reply is constructed for the operation.

Expression form

list_remove_by_index

Throws

An Operation Not Applicable error (code 26) when trying to remove an inaccessible index.

Performance

The worst-case performance of removing the element by index is 𝓞(1) for an ordered list with a persisted index, and 𝓞(N) for an ordered list without a persisted index or an unordered list.

Code sample 
// scores = [10, 20, 30, 40, 50]


try (RecordStream rs = session.upsert(key)
    .bin("scores").onListIndex(2).removeAnd().getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 30
}
// scores == [10, 20, 40, 50]

remove_by_rank_range 

remove_by_rank_range(bin_name, rank[, count], result_type[, context])
Description

Removes a range of count elements starting at a specified rank. The INVERTED flag may be used to remove the elements not in a specified range.

The rank and count can be any number, but the result may be an empty list if the specified range contains no elements.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

rankinteger

Zero-based rank in value order, 0 being the smallest. A negative rank counts back from the largest.

countinteger

Number of elements to select. Optional; defaults to the rest of the collection.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The NONE return type will execute faster because no reply is constructed for the operation. The elements returned by other return types may not be in rank order.

Expression form

list_remove_by_rank, list_remove_by_rank_range, list_remove_by_rank_range_to_end

Performance

The worst-case performance of removing elements by rank range is 𝓞(M) for an ordered list with a persisted index. An ordered list without a persisted index has a 𝓞(N + M), where M is the element count of the range, and N is the element count of the list. An unordered list has a 𝓞(R log N + N).

Examples
Example

For [1, 3, 2, 7, 0] with return type NONE a range starting at rank 2 and containing 2 elements removes [2, 3], while the INVERTED | NONE of the same range removes [0, 1, 7].

Code sample 
// l = [1, 3, 2, 7, 0]


try (RecordStream rs = session.upsert(key)
    .bin("l").onListRankRange(2, 2).remove()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// l == [1, 7, 0]


// INVERTED: remove everything outside the range
// l = [1, 3, 2, 7, 0]


try (RecordStream rs = session.upsert(key)
    .bin("l").onListRankRange(2, 2).removeAllOthers()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// l == [3, 2]

remove_by_value_interval 

remove_by_value_range(bin_name, value_begin, value_end, result_type[, context])
Description

Removes the list elements that sort into the interval between valueStart (inclusive) and valueStop (exclusive). The INVERTED flag may be used to remove the elements outside this interval.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

value_beginany

Lowest value to match, inclusive.

value_endany

Upper bound on the value, exclusive. Omit it to match everything from value_begin upward.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The elements returned may not be in index order.

Expression form

list_remove_by_value_range

Order

Whether the list is unordered or ordered, remove_by_value_interval will return the same elements, based on the ordering rules. The performance of ‘by value’ operations is better on an ordered list than an unordered one.

Performance

The worst-case performance of removing elements in a value interval is 𝓞(log N + M) for an ordered list with a persisted index, 𝓞(log N + N) for an ordered list without a persisted index, and 𝓞(N + M) for an unordered list, where M is the number of items in the parameter list and N is the number of items already in the list.

Examples
Trivial example

Remove the list elements in the interval between two scalar values. See the code sample below.

Interval comparison of tuples

It is common to model complex data in Aerospike as a list of tuples, each element a list, where the index order carries meaning. For an example, see Aerospike Modeling: IoT Sensors.

This modeling relies on the ordering rules that apply to list elements. Ordered pairs sort into

[1, NIL] < [1, 1] < [1, 1, 2] < [1, 2] < [1, '1'] < [1, 1.0] < [1, INF]

Take the list of ordered pairs, [[100, 1], [101, 2], [102, 3], [103, 4], [104, 5]] and the following intervals:

valueStart: [101, NIL], valueStop: [103, NIL]

Iterating over the elements we check if [101, NIL] <= value < [103, NIL]. This is true for the elements [101, 2] and [102, 3]. The element [103, 4] is not in this interval, because its order is higher than [103, NIL]. The comparison starts with the 0th index values, in this case both are 103. Next the 1st index position values are compared, and NIL is lower than 3 (actually its order is lower than any value).

valueStart: [101, NIL], valueStop: [103, INF]

The elements [101, 2] and [102, 3] are obviously in the interval. The element [103, 4] is also in this interval, because its order is lower than [103, INF]. The comparison starts with the 0th index values, in this case both are 103. Next the 1st index position values are compared, and INF is higher than 3 (actually its order is higher than any value).

valueStart: [101, INF], valueStop: [103, INF]

The elements [102, 3] and [103, 4] are in the interval. The element [101, 2] is not in this interval, because its order is lower than [101, INF].

Code sample 
// l = [1, 2, 3, 4, 5, 4, 3, 2, 1]


// remove all elements in the interval [2, 4), then read the bin
try (RecordStream rs = session.upsert(key)
    .bin("l").onListValueRange(2, 4).remove()
    .bin("l").get()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// l == [1, 4, 5, 4, 1]

remove_by_value_rel_rank_range 

remove_by_value_rel_rank_range(bin_name, value, rank[, count], result_type[, context])
Description

Removes a range of count elements starting at a specified rank, relative to the given value. The INVERTED flag may be used to remove the elements not in a specified range.

The value can be anything, not necessarily a value that exists in the list. The rank and count can be any number, but the result may be an empty list if the specified range contains no elements.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

valueany

Value that rank is measured from. It need not be present in the collection — the rank is taken from where it would sort.

rankinteger

Zero-based rank in value order, 0 being the smallest. A negative rank counts back from the largest.

countinteger

Number of elements to select. Optional; defaults to the rest of the collection.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The elements returned may not be in rank order.

Expression form

list_remove_by_rel_rank_range, list_remove_by_rel_rank_range_to_end

Order

The relative rank of the value compared to the current list follows the ordering rules.

Performance

The worst-case performance of removing elements by relative rank range is 𝓞(M + log N) for an ordered list with a persisted index. An ordered list without a persisted index has a 𝓞(N + M + log N), where M is the element count of the range, and N is the element count of the list. An unordered list has a 𝓞(R log N + N), with R for rank.

Examples
Example

For [0, 3, 9, 12, 15] a value of 5 would rank between 3 and 9, relative to the current list. A rank of -1 from there would select 3 as the starting point of the range, and then the count would select the elements. So a count of 3 would remove the elements 3, 9 and 12.

Code sample 
// scores = [0, 3, 9, 12, 15]
// Relative rank of value 5: between 3 and 9 (rank position 2)
// rank offset -1, count 3 → remove ranks 1..3


try (RecordStream rs = session.upsert(key)
    .bin("scores").onListValueRelativeRankRange(5, -1, 3)
        .removeAnd().getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 3, 9 and 12, in no guaranteed order
}
// scores == [0, 15]

set 

set(policy, bin_name, index, value[, context])
Description

Creates an unordered list bin, if the bin does not exist. Sets or overwrites a value at the specified list index. (This set function has no relation to the Aerospike concept of sets as a collection of records.)

By default the index can be any number, and NIL values will be added as padding to the left of the new element, as needed. Using the INSERT_BOUNDED policy, a developer can limit this behavior, and only allow for an element to be set at an index value between 0 and the size of the list.

You cannot set a value in an ordered list, only append or append_items to one.

Arguments
NameTypeDescription
policyList policy

Ordering and write flags for the operation. See Write flags. The ordering attribute takes effect only when this operation creates the list; on a list that already exists it is ignored.

bin_namestring

Name of the bin to operate on.

indexinteger

Zero-based position, 0 being the first element. A negative index counts back from the end.

valueany

Element to write at index, replacing what is there.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

The element count due to the operation, in the ‘bins’ part of the record under the bin name.

Expression form

list_set

Order

A list newly created with set() is always unordered.

Performance

The worst-case performance of setting an item at the head of a list (at its 0th index) is 𝓞(1). At any other index it is 𝓞(N).

Code sample 
// scores = [10, 20, 30]


try (RecordStream rs = session.upsert(key)
    .bin("scores").listSet(1, 25)
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// scores == [10, 25, 30]

sort 

sort(bin_name, sort_flags[, context])
Description

Sorts a list, but doesn’t change the list order. An unordered list will remain unordered after being sorted. An ordered list doesn’t need to be sorted, because by definition it sorts itself any time elements are added to it.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

sort_flagsinteger literal

Sort flags: 0 sorts ascending, 2 sorts ascending and drops duplicate values.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

null

Expression form

list_sort

Sort Flags
FlagDescription
DEFAULTDefault keep duplicates
DROP_DUPLICATESDrop duplicates while sorting
Performance

The sort operation will do no work when called on an already ordered list. The worst-case performance of sorting an unordered list is 𝓞(N log N).

Code sample 
// scores = [30, 10, 50, 20, 40]


try (RecordStream rs = session.upsert(key)
    .bin("scores").listSort()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// scores == [10, 20, 30, 40, 50]

Read operations

get_all_by_value_list 

get_by_value_list(bin_name, values, result_type[, context])
Description

Gets all the elements in the list matching one of the specified values. The INVERTED flag may be used to get the elements not matching any of the values.

Whether the list is unordered or ordered, get_all_by_value_list will return the same elements, based on the ordering rules. The performance of ‘by value’ operations is better on an ordered list than an unordered one.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

valueslist

Values to match, as a list. Every element equal to any of them is selected.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The elements returned may not be in index order.

Expression form

list_get_by_value_list

Performance

The worst-case performance of getting elements by a value list is 𝓞((M+N) log M) for an ordered list with a persisted index, 𝓞((M+N) log M + N) for an ordered list without a persisted index, or for an unordered list, where M is the number of items in the parameter list and N is the number of items already in the list.

Examples
Trivial example

Count the number of elements in the list matching one of several specified scalar values. See the code sample below.

Matching tuples with wildcard

See the example given for get_all_by_value.

In a list of mostly ordered pairs, we could search for all the tuples that do not start with “v1” or “v2”, by using a wildcard and an INVERTED | VALUE return type.

The wildcard matches any sequence of elements to the end of the tuple. In this example, this means matching any tuple whose first position is “v1” or “v2”, and whose size is two or more elements.

The wildcard has different language-specific constructs, such as aerospike.CDTWildcard() in the Python client and Value.WILDCARD in the Java client.

Code sample 
// Trivial example
// l = [1, 2, 3, 2, 1]


try (RecordStream rs = session.query(key)
    .bin("l").onListValueList(List.of(2, 3)).count()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 3
}


// Matching tuples with wildcard (INVERTED)
// l = [["v1", 1], ["v2", 2], ["v3", 3], ["v2", 4]]


try (RecordStream rs = session.query(key)
    .bin("l").onListValueList(List.of(
        List.of("v2", SpecialValue.WILDCARD),
        List.of("v1", SpecialValue.WILDCARD))).getAllOtherValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns [["v3", 3]]
}

get_all_by_value 

get_by_value(bin_name, value, result_type[, context])
Description

Gets all the elements in the list matching value. The INVERTED flag may be used to get the elements not matching the specified value.

Whether the list is unordered or ordered, get_all_by_value will return the same elements, based on the ordering rules. The performance of ‘by value’ operations is better on an ordered list than an unordered one.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

valueany

Value to match. Every element equal to it is selected.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The elements returned may not be in index order.

Expression form

list_get_by_value

Performance

The worst-case performance of getting elements by value is 𝓞(log N + M) for an ordered list with a persisted index, 𝓞(log N + N) for an ordered list without a persisted index, and 𝓞(N + M) for an unordered list, where M is the number of items in the parameter list and N is the number of items already in the list.

Examples
Trivial example

Count the number of elements in the list with a specified scalar value. See the code sample below.

Matching tuples with wildcard

It is common to model complex data in Aerospike as a list of tuples, each element a list, where the index order carries meaning. For an example, see Aerospike Modeling: IoT Sensors.

In a list of mostly ordered pairs, we could search for a specific kind of element, such as all the tuples where the 0th position is “v2”, by using a wildcard (typically stylized as a * in documentation).

The wildcard matches any sequence of elements to the end of the tuple. In this example, this means matching any tuple whose first position is “v2”, and whose size is two or more elements.

The wildcard has different language-specific constructs, such as aerospike.CDTWildcard() in the Python client and Value.WILDCARD in the Java client.

Code sample 
// Trivial example
// l = [1, 2, 1, 2]


try (RecordStream rs = session.query(key)
    .bin("l").onListValue(2).count()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 2
}


// Matching tuples with wildcard
// l = [["v1", 1], ["v2", 2], ["v1", 3], ["v2", 4, {"a": 1}]]


try (RecordStream rs = session.query(key)
    .bin("l").onListValue(List.of("v2", SpecialValue.WILDCARD)).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns [["v2", 2], ["v2", 4, {"a": 1}]]
}

get_by_index_range 

get_by_index_range(bin_name, index[, count], result_type[, context])
Description

Gets a range of count elements starting at a specified list index. The INVERTED flag may be used to get the elements not in a specified range.

The index and count can be any number, but the result may be an empty list if the specified range contains no elements.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

indexinteger

Zero-based position, 0 being the first element. A negative index counts back from the end.

countinteger

Number of elements to select. Optional; defaults to the rest of the collection.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

One or a list values, based on the return type. The elements returned may not be in index order.

Expression form

list_get_by_index_range, list_get_by_index_range_to_end

Performance

The worst-case performance of getting elements by index range is 𝓞(M) for an ordered list with a persisted index, and 𝓞(N + M) for an ordered list without a persisted index or an unordered list, where M is the element count of the range, and N is the element count of the list. Requesting a RANK return type on an unordered list adds 𝓞(L*N). See List performance.

Examples
Example

For [1, 3, 3, 7, 0] the VALUE range starting at index 2 and containing 3 elements gives back [3, 7, 0], while the INVERTED | VALUE of the same range gives back [1, 3].

Code sample 
// l = [1, 3, 3, 7, 0]


try (RecordStream rs = session.query(key)
    .bin("l").onListIndexRange(2, 3).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns [3, 7, 0]
}


try (RecordStream rs = session.query(key)
    .bin("l").onListIndexRange(2, 3).getAllOtherValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns [1, 3]
}

get_by_index 

get_by_index(bin_name, index, result_type[, context])
Description

Gets the element at the specified list index. The index must be a number between 0 and N-1, where N is the length of the list. The index can also be a negative number, with -1 being the last element by index position.

On an ordered list this operation with a VALUE return type will be the same as a list get_by_rank operation.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

indexinteger

Zero-based position, 0 being the first element. A negative index counts back from the end.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

A single result, based on the return type.

Expression form

list_get_by_index

Throws

An Operation Not Applicable error (code 26) when trying to get an inaccessible index.

Performance

The worst-case performance of getting the element by index is 𝓞(1) for an ordered list with a persisted index, and 𝓞(N) for an ordered list without a persisted index or an unordered list.

Examples
Example

[1, 3, 3, 7, 0] modified with set_order to ORDERED will turn into [0, 1, 3, 3, 7].

The value of the element at index -1 is 7, the rank at -1 is 7.

The value of the element at index 2 is 3, the element with rank 2 is 3.

Code sample 
// l = [0, 1, 3, 3, 7] (ORDERED)


try (RecordStream rs = session.query(key)
    .bin("l").onListIndex(2).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 3
}


try (RecordStream rs = session.query(key)
    .appendOperations(ListOperation.getByIndex("l", 2, ListReturnType.RANK))
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 2
}


try (RecordStream rs = session.query(key)
    .bin("l").onListIndex(-1).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 7
}

get_by_rank_range 

get_by_rank_range(bin_name, rank[, count], result_type[, context])
Description

Gets a range of count elements starting at a specified rank. The INVERTED flag may be used to get the elements not in a specified range.

The rank and count can be any number, but the result may be an empty list if the specified range contains no elements.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

rankinteger

Zero-based rank in value order, 0 being the smallest. A negative rank counts back from the largest.

countinteger

Number of elements to select. Optional; defaults to the rest of the collection.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

One or a list of values, based on the return type. The elements returned may not be in rank order.

Expression form

list_get_by_rank_range, list_get_by_rank_range_to_end

Performance

The worst-case performance of getting elements by rank range is 𝓞(M) for an ordered list with a persisted index. An ordered list without a persisted index has a 𝓞(N + M), where M is the element count of the range, and N is the element count of the list. An unordered list has a 𝓞(R log N + N).

Examples
Example

For [1, 3, 2, 7, 0] the VALUE range starting at rank 2 and containing 2 elements gives back 2 and 3, while the INVERTED | VALUE of the same range gives back 0, 1 and 7, both in no guaranteed order.

Code sample 
// l = [1, 3, 2, 7, 0]


try (RecordStream rs = session.query(key)
    .bin("l").onListRankRange(2, 2).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 2 and 3, in no guaranteed order
}


try (RecordStream rs = session.query(key)
    .bin("l").onListRankRange(2, 2).getAllOtherValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 0, 1 and 7, in no guaranteed order
}

get_by_rank 

get_by_rank(bin_name, rank, result_type[, context])
Description

Gets the element with the specified rank order. The rank must be a number between 0 (lowest rank) and N-1 (highest rank), where N is the length of the list. The rank can also be a negative number, with -1 being the element with the highest rank.

On an ordered list this operation with a VALUE return type will be the same as a list get_by_index operation, (see this example).

Whether the list is unordered or ordered, get_by_rank will return the same elements, based on the ordering rules. The performance of ‘by rank’ operations is better on an ordered list than an unordered one.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

rankinteger

Zero-based rank in value order, 0 being the smallest. A negative rank counts back from the largest.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

A single result, based on the return type.

Expression form

list_get_by_rank

Throws

An Operation Not Applicable error (code 26) when trying to get an inaccessible rank.

Performance

The worst-case performance of getting an element by rank is 𝓞(1) for an ordered list with a persisted index, 𝓞(N) for an ordered list without a persisted index, and 𝓞(R log N + N) for an unordered list.

Examples
Example

For [30, 10, 50, 20, 40] the element at rank 0 is 10 (lowest value), and the element at rank -1 is 50 (highest value).

Code sample 
// l = [30, 10, 50, 20, 40]


try (RecordStream rs = session.query(key)
    .bin("l").onListRank(0).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 10 (lowest rank)
}


try (RecordStream rs = session.query(key)
    .bin("l").onListRank(-1).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 50 (highest rank)
}


try (RecordStream rs = session.query(key)
    .appendOperations(ListOperation.getByRank("l", -1, ListReturnType.INDEX))
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 2
}

get_by_value_interval 

get_by_value_range(bin_name, value_begin, value_end, result_type[, context])
Description

Gets the list elements that sort into the interval between valueStart (inclusive) and valueStop (exclusive). The INVERTED flag may be used to get the elements outside this interval.

Whether the list is unordered or ordered, get_by_value_interval will return the same elements, based on the ordering rules. The performance of ‘by value’ operations is better on an ordered list than an unordered one.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

value_beginany

Lowest value to match, inclusive.

value_endany

Upper bound on the value, exclusive. Omit it to match everything from value_begin upward.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The elements returned may not be in index order.

Expression form

list_get_by_value_range

Performance

The worst-case performance of getting elements in a value interval is 𝓞(log N + M) for an ordered list with a persisted index, 𝓞(log N + N) for an ordered list without a persisted index, and 𝓞(N + M) for an unordered list, where M is the number of items in the parameter list and N is the number of items already in the list.

Examples
Trivial example

Get the list elements in the interval between two scalar values. See the code sample below.

Interval comparison of tuples

It is common to model complex data in Aerospike as a list of tuples, each element a list, where the index order carries meaning. For an example, see Aerospike Modeling: IoT Sensors.

This modeling relies on the ordering rules that apply to list elements. Ordered pairs sort into

[1, NIL] < [1, 1] < [1, 1, 2] < [1, 2] < [1, '1'] < [1, 1.0] < [1, INF]

Take the list of ordered pairs, [[100, 1], [101, 2], [102, 3], [103, 4], [104, 5]] and the following intervals:

valueStart: [101, NIL], valueStop: [103, NIL]

Iterating over the elements we check if [101, NIL] <= value < [103, NIL]. This is true for the elements [101, 2] and [102, 3]. The element [103, 4] is not in this interval, because its order is higher than [103, NIL]. The comparison starts with the 0th index values, in this case both are 103. Next the 1st index position values are compared, and NIL is lower than 3 (actually its order is lower than any value).

valueStart: [101, NIL], valueStop: [103, INF]

The elements [101, 2] and [102, 3] are obviously in the interval. The element [103, 4] is also in this interval, because its order is lower than [103, INF]. The comparison starts with the 0th index values, in this case both are 103. Next the 1st index position values are compared, and INF is higher than 3 (actually its order is higher than any value).

valueStart: [101, INF], valueStop: [103, INF]

The elements [102, 3] and [103, 4] are in the interval. The element [101, 2] is not in this interval, because its order is lower than [101, INF].

Code sample 
// l = [1, 2, 3, 4, 5, 4, 3, 2, 1]


// get all elements in the interval [2, 4)
try (RecordStream rs = session.query(key)
    .bin("l").onListValueRange(2, 4).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns [2, 3, 3, 2]
}

get_by_value_rel_rank_range 

get_by_value_rel_rank_range(bin_name, value, rank[, count], result_type[, context])
Description

Gets a range of count elements starting at a rank offset from the relative rank of the given value. The INVERTED flag may be used to get the elements not in this range.

The value can be anything, not necessarily a value that exists in the list. The rank and count can be any number, but the result may be an empty list if the specified range contains no elements.

The relative rank of the value compared to the current list follows the ordering rules.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

valueany

Value that rank is measured from. It need not be present in the collection — the rank is taken from where it would sort.

rankinteger

Zero-based rank in value order, 0 being the smallest. A negative rank counts back from the largest.

countinteger

Number of elements to select. Optional; defaults to the rest of the collection.

result_typeinteger literal

Which form the result takes — a count, an index, a rank, a value, or nothing. See Return types.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Zero, one or a list of values, based on the return type. The elements returned may not be in index order.

Expression form

list_get_by_rel_rank_range, list_get_by_rel_rank_range_to_end

Performance

The worst-case performance of getting elements by relative rank range is 𝓞(M + log N) for an ordered list with a persisted index. An ordered list without a persisted index has a 𝓞(N + M + log N), where M is the element count of the range, and N is the element count of the list. An unordered list has a 𝓞(R log N + N), with R for rank.

Formula 
origin = relative-rank(_value_) # compared to the current list elements
r = rank(element)


Get all elements in the range where
(r >= (origin + _rank_)) and (r < (origin + _rank_ + _count_))
Examples
Example

For [0, 3, 9, 12, 15] a value of 5 would rank between 3 and 9, relative to the current list. A rank of -1 from there would select 3 as the starting point of the range, and then the count would select the elements. So a count of 3 would return the range 3, 9 and 12.

Code sample 
// scores = [0, 3, 9, 12, 15]
// Relative rank of value 5: between 3 and 9 (rank position 2)
// rank offset -1, count 3 → start at rank 1, get 3 elements


try (RecordStream rs = session.query(key)
    .bin("scores").onListValueRelativeRankRange(5, -1, 3).getValues()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 3, 9 and 12, in no guaranteed order
}

join 

join(bin_name[, separator][, context])
Description

Concatenates the string elements of a list into a single string and returns it, without modifying the list. An optional separator is placed between consecutive elements; omit it to concatenate with nothing between them. An optional context targets a nested list.

Every element must be a string. An empty list returns an empty string, and a single-element list returns that element with no separator applied.

This is the inverse of the string split operation. join is a List operation rather than a string operation, because it reads a list bin.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

separatorstring

String placed between elements. Omit it to join them with nothing in between.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

A single string holding the concatenated elements.

Introduced
8.2.0
Expression form

list_join

Throws

A Parameter error (code 4) when any element is not a string, when the separator is not a string, when the bin does not hold a valid list, or when the joined result would exceed the server’s size limit. The Java and C# clients name this code PARAMETER_ERROR; the C client names it AEROSPIKE_ERR_REQUEST_INVALID. They are the same code.

All but the separator case carry error-detail subcode AS_SUB_PARAM_STRING_OP_PARAMS_INVALID (6) and name the cause in the message, identifying the offending element by index for a non-string element. A non-string separator reports no subcode. See error detail subcodes for the full list.

Performance

The worst-case performance of joining the list is 𝓞(N), where N is the number of elements.

Examples
Join with a separator

Given tags = ["red", "green", "blue"], calling join("tags", ", ") returns "red, green, blue".

Calling join("tags") with no separator returns "redgreenblue".

Empty and single-element lists

An empty list returns an empty string rather than an error, so a join over a list that may be empty needs no guard. A single-element list returns that element unchanged, because a separator is only placed between elements.

Code sample 
// tags = ["red", "green", "blue"]


try (RecordStream rs = session.query(key)
    .bin("tags").listJoin(", ")
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns "red, green, blue"
}

size 

size(bin_name[, context])
Description

Gets the size of a list, optionally at a given subcontext.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

Returns the count of elements in the list at the level specified.

Expression form

list_size

Performance

The worst-case performance of getting the size of the list is 𝓞(1).

Code sample 
// scores = [10, 20, 30, 40, 50]


try (RecordStream rs = session.query(key)
    .bin("scores").listSize()
    .execute()) {
    Record rec = rs.next().recordOrThrow();
    // returns 5
}

Set operations

set_order 

set_order(bin_name, order[, context])
Description

Modifies the order of an existing list. Order can be UNORDERED (default) or ORDERED. An optional persistIndex flag stores the offset index on disk alongside the list for O(1) index access on subsequent operations.

Once set, both the order and persist-index flags are preserved across all subsequent list operations until changed by another set_order() call. The persist-index flag applies only to top-level lists.

See CDT Element Ordering and Comparison.

Arguments
NameTypeDescription
bin_namestring

Name of the bin to operate on.

orderinteger literal

List order to set: 0 for unordered, 1 for ordered by value.

contextContext instance

Optional context path from the bin to a nested List or Map, one selector per nesting level. Omit it to operate on the top level of the list.

Returns

null

Performance

The set_order operation does nothing when called on an already ordered list or on an ordered-to-unordered transition. The worst-case performance of modifying an unordered list to an ordered one is 𝓞(N log N).

Examples
Example

[1, 3, [3, 7], 0, [3, 2]] modified with set_order to ORDERED will turn into [0, 1, 3, [3, 2], [3, 7]], because a list has higher ranking order than integers, and the list elements are compared by index when sorted.

Code sample 
// l = [1, 3, [3, 7], 0, [3, 2]]


try (RecordStream rs = session.upsert(key)
    .bin("l").listSetOrder(ListOrder.ORDERED)
    .execute()) {
    Record rec = rs.next().recordOrThrow();
}
// l == [0, 1, 3, [3, 2], [3, 7]]