ArrayPipelineBinaryCommands (Jedis 8.0.0 API)

All Known Subinterfaces:

PipelineBinaryCommands

All Known Implementing Classes:

AbstractPipeline, AbstractTransaction, ClusterPipeline, MultiDbPipeline, MultiDbTransaction, MultiNodePipelineBase, Pipeline, PipeliningBase, ReliableTransaction, Transaction
```
public interface ArrayPipelineBinaryCommands
```
Binary pipeline and transaction commands for the Redis array data type.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`Response<java.lang.Long>`	`arcount(byte[] key)` ARCOUNT Command Returns the number of non-empty elements in an array.
`Response<java.lang.Long>`	`ardel(byte[] key, long... indices)` ARDEL Command Deletes elements at the specified indices in an array.
`Response<java.lang.Long>`	`ardel(byte[] key, long index)` ARDEL Command Deletes the element at a single index in an array.
`Response<java.lang.Long>`	`ardelrange(byte[] key, long start, long end)` ARDELRANGE Command Convenience single-range overload of `ardelrange(byte[], LongRange...)`.
`Response<java.lang.Long>`	`ardelrange(byte[] key, LongRange... ranges)` ARDELRANGE Command Deletes elements in one or more inclusive `LongRange` ranges of indices.
`Response<byte[]>`	`arget(byte[] key, long index)` ARGET Command Returns the value stored at a single index in an array.
`Response<java.util.List<byte[]>>`	`argetrange(byte[] key, long start, long end)` ARGETRANGE Command Returns the values at a contiguous range of indices.
`Response<java.util.List<java.lang.Long>>`	`argrep(byte[] key, ArgrepParams params)` ARGREP Command Searches array elements within an inclusive index range (carried by `ArgrepParams`) using one or more textual predicates and returns the matching indices.
`Response<java.util.List<KeyValue<java.lang.Long,byte[]>>>`	`argrepWithValues(byte[] key, ArgrepParams params)` ARGREP Command Searches array elements within an inclusive index range (carried by `ArgrepParams`) and returns the matching index/value pairs.
`Response<ArrayInfo>`	`arinfo(byte[] key)` ARINFO Command Returns metadata describing an array.
`Response<ArrayFullInfo>`	`arinfoFull(byte[] key)` ARINFO Command Returns the `FULL` variant of the array metadata.
`Response<java.lang.Long>`	`arinsert(byte[] key, byte[]... values)` ARINSERT Command Inserts one or more values at consecutive indices beginning at the current insert cursor position.
`Response<java.lang.Long>`	`arinsert(byte[] key, byte[] value)` ARINSERT Command Convenience single-value overload of `arinsert(byte[], byte[]...)`.
`Response<java.util.List<byte[]>>`	`arlastitems(byte[] key, long count)` ARLASTITEMS Command Returns the most recently inserted elements in oldest-first order.
`Response<java.util.List<byte[]>>`	`arlastitems(byte[] key, long count, boolean rev)` ARLASTITEMS Command Returns the most recently inserted elements.
`Response<java.lang.Long>`	`arlen(byte[] key)` ARLEN Command Returns the length of an array (max index + 1).
`Response<java.util.List<byte[]>>`	`armget(byte[] key, long... indices)` ARMGET Command Returns the values at multiple indices.
`Response<java.lang.Long>`	`armset(byte[] key, java.util.Map<java.lang.Long,byte[]> indexValueMap)` ARMSET Command Sets multiple index-value pairs.
`Response<java.lang.Long>`	`arnext(byte[] key)` ARNEXT Command Returns the next index that `ARINSERT` would use.
`Response<byte[]>`	`aropAggregate(byte[] key, long start, long end, ArrayAggregate op)` AROP Command Applies a numeric aggregate over the non-empty elements in the inclusive `[start, end]` range.
`Response<java.lang.Long>`	`aropBitwise(byte[] key, long start, long end, ArrayBitwise op)` AROP Command Applies a bitwise operation over the non-empty elements in the inclusive `[start, end]` range.
`Response<java.lang.Long>`	`aropCount(byte[] key, long start, long end)` AROP Command Counts the number of non-empty elements in the inclusive `[start, end]` range using the `USED` subcommand.
`Response<java.lang.Long>`	`aropCount(byte[] key, long start, long end, byte[] match)` AROP Command Counts elements in the inclusive `[start, end]` range whose value equals `match` using the `MATCH` subcommand.
`Response<java.lang.Long>`	`arring(byte[] key, long size, byte[]... values)` ARRING Command Inserts one or more values into an array as a fixed-size ring buffer.
`Response<java.lang.Long>`	`arring(byte[] key, long size, byte[] value)` ARRING Command Convenience single-value overload of `arring(byte[], long, byte[]...)`.
`Response<java.util.List<KeyValue<java.lang.Long,byte[]>>>`	`arscan(byte[] key, long start, long end)` ARSCAN Command Iterates existing elements in an inclusive index range and returns the index/value pairs.
`Response<java.util.List<KeyValue<java.lang.Long,byte[]>>>`	`arscan(byte[] key, long start, long end, long limit)` ARSCAN Command Iterates existing elements in an inclusive index range with a cap on the number of pairs returned.
`Response<java.lang.Long>`	`arseek(byte[] key, long index)` ARSEEK Command Sets the insert cursor of an array to a specific index.
`Response<java.lang.Long>`	`arset(byte[] key, long index, byte[]... values)` ARSET Command Sets one or more contiguous values starting at `index`.
`Response<java.lang.Long>`	`arset(byte[] key, long index, byte[] value)` ARSET Command Convenience single-value overload of `arset(byte[], long, byte[]...)`.

- Method Detail
  - arcount
```
@Experimental
Response<java.lang.Long> arcount(byte[] key)
```
    ARCOUNT Command Returns the number of non-empty elements in an array.
    Time complexity: O(1)
    Wire: ARCOUNT key
    
    Parameters:
    
    key - the name of the key that holds the array
    
    Returns:
    
    a Response that resolves to the number of non-empty elements, or 0 if key does not exist
    
    Since:
    
    8.0
  - ardel
```
@Experimental
Response<java.lang.Long> ardel(byte[] key,
                                             long index)
```
    ARDEL Command Deletes the element at a single index in an array.
    Time complexity: O(1)
    Wire: ARDEL key index
    
    Parameters:
    
    key - the name of the key that holds the array
    
    index - the zero-based index to delete
    
    Returns:
    
    a Response that resolves to 1 if an element was deleted, 0 otherwise
    
    Since:
    
    8.0
  - ardel
```
@Experimental
Response<java.lang.Long> ardel(byte[] key,
                                             long... indices)
```
    ARDEL Command Deletes elements at the specified indices in an array.
    Time complexity: O(N) where N is the number of indices supplied.
    Wire: ARDEL key index1 [index2 ...]
    
    Parameters:
    
    key - the name of the key that holds the array
    
    indices - one or more zero-based indices to delete
    
    Returns:
    
    a Response that resolves to the number of elements actually deleted
    
    Since:
    
    8.0
  - ardelrange
```
@Experimental
Response<java.lang.Long> ardelrange(byte[] key,
                                                  LongRange... ranges)
```
    ARDELRANGE Command Deletes elements in one or more inclusive LongRange ranges of indices.
    Time complexity: O(M + N) where M is the number of ranges and N the total number of elements they cover.
    Wire: ARDELRANGE key r1.start r1.end [r2.start r2.end ...]
    
    Parameters:
    
    key - the name of the key that holds the array
    
    ranges - one or more inclusive index ranges
    
    Returns:
    
    a Response that resolves to the number of elements deleted
    
    Since:
    
    8.0
  - ardelrange
```
@Experimental
Response<java.lang.Long> ardelrange(byte[] key,
                                                  long start,
                                                  long end)
```
    ARDELRANGE Command Convenience single-range overload of ardelrange(byte[], LongRange...).
    Wire: ARDELRANGE key start end
    
    Parameters:
    
    key - the name of the key that holds the array
    
    start - zero-based start index (inclusive)
    
    end - zero-based end index (inclusive)
    
    Returns:
    
    a Response that resolves to the number of elements deleted
    
    Since:
    
    8.0
  - arget
```
@Experimental
Response<byte[]> arget(byte[] key,
                                     long index)
```
    ARGET Command Returns the value stored at a single index in an array.
    Time complexity: O(1)
    Wire: ARGET key index
    
    Parameters:
    
    key - the name of the key that holds the array
    
    index - the zero-based index of the element to retrieve
    
    Returns:
    
    a Response that resolves to the value at the given index, or null if the key or index does not exist
    
    Since:
    
    8.0
  - argetrange
```
@Experimental
Response<java.util.List<byte[]>> argetrange(byte[] key,
                                                          long start,
                                                          long end)
```
    ARGETRANGE Command Returns the values at a contiguous range of indices.
    Time complexity: O(N) where N is the number of elements in the range.
    Wire: ARGETRANGE key start end
    
    Parameters:
    
    key - the name of the key that holds the array
    
    start - zero-based start index of the range
    
    end - zero-based end index of the range (inclusive)
    
    Returns:
    
    a Response that resolves to the list of values in traversal order; empty slots appear as null entries
    
    Since:
    
    8.0
  - argrep
```
@Experimental
Response<java.util.List<java.lang.Long>> argrep(byte[] key,
                                                              ArgrepParams params)
```
    ARGREP Command Searches array elements within an inclusive index range (carried by ArgrepParams) using one or more textual predicates and returns the matching indices.
    Time complexity: O(N) where N is the number of elements scanned.
    Wire: ARGREP key start end <params>
    
    Parameters:
    
    key - the name of the key that holds the array
    
    params - the search range, predicates and options to apply
    
    Returns:
    
    a Response that resolves to the matching indices in traversal order
    
    Since:
    
    8.0
  - argrepWithValues
```
@Experimental
Response<java.util.List<KeyValue<java.lang.Long,byte[]>>> argrepWithValues(byte[] key,
                                                                                         ArgrepParams params)
```
    ARGREP Command Searches array elements within an inclusive index range (carried by ArgrepParams) and returns the matching index/value pairs.
    Time complexity: O(N) where N is the number of elements scanned.
    Wire: ARGREP key start end <params> WITHVALUES
    
    Parameters:
    
    key - the name of the key that holds the array
    
    params - the search range, predicates and options to apply
    
    Returns:
    
    a Response that resolves to the matching index/value pairs
    
    Since:
    
    8.0
  - arinfo
```
@Experimental
Response<ArrayInfo> arinfo(byte[] key)
```
    ARINFO Command Returns metadata describing an array.
    Time complexity: O(1)
    Wire: ARINFO key
    
    Parameters:
    
    key - the name of the key that holds the array
    
    Returns:
    
    a Response that resolves to a typed ArrayInfo, or null if the key does not exist
    
    Since:
    
    8.0
  - arinfoFull
```
@Experimental
Response<ArrayFullInfo> arinfoFull(byte[] key)
```
    ARINFO Command Returns the FULL variant of the array metadata.
    Time complexity: O(S) where S is the number of slices.
    Wire: ARINFO key FULL
    
    Parameters:
    
    key - the name of the key that holds the array
    
    Returns:
    
    a Response that resolves to a typed ArrayFullInfo, or null if the key does not exist
    
    Since:
    
    8.0
  - arinsert
```
@Experimental
Response<java.lang.Long> arinsert(byte[] key,
                                                byte[]... values)
```
    ARINSERT Command Inserts one or more values at consecutive indices beginning at the current insert cursor position.
    Time complexity: O(N) where N is the number of values inserted.
    Wire: ARINSERT key value1 [value2 ...]
    
    Parameters:
    
    key - the name of the key that holds the array
    
    values - one or more values to insert
    
    Returns:
    
    a Response that resolves to the last index at which a value was inserted
    
    Since:
    
    8.0
  - arinsert
```
@Experimental
Response<java.lang.Long> arinsert(byte[] key,
                                                byte[] value)
```
    ARINSERT Command Convenience single-value overload of arinsert(byte[], byte[]...).
    Wire: ARINSERT key value
    
    Parameters:
    
    key - the name of the key that holds the array
    
    value - the value to insert
    
    Returns:
    
    a Response that resolves to the index at which the value was inserted
    
    Since:
    
    8.0
  - arlastitems
```
@Experimental
Response<java.util.List<byte[]>> arlastitems(byte[] key,
                                                           long count)
```
    ARLASTITEMS Command Returns the most recently inserted elements in oldest-first order.
    Time complexity: O(N) where N is the number of returned elements.
    Wire: ARLASTITEMS key count
    
    Parameters:
    
    key - the name of the key that holds the array
    
    count - the maximum number of elements to return
    
    Returns:
    
    a Response that resolves to the list of last-inserted values
    
    Since:
    
    8.0
  - arlastitems
```
@Experimental
Response<java.util.List<byte[]>> arlastitems(byte[] key,
                                                           long count,
                                                           boolean rev)
```
    ARLASTITEMS Command Returns the most recently inserted elements. When rev is true, elements are returned in reverse chronological order.
    Time complexity: O(N) where N is the number of returned elements.
    Wire: ARLASTITEMS key count [REV]
    
    Parameters:
    
    key - the name of the key that holds the array
    
    count - the maximum number of elements to return
    
    rev - whether to request the REV variant
    
    Returns:
    
    a Response that resolves to the list of last-inserted values
    
    Since:
    
    8.0
  - arlen
```
@Experimental
Response<java.lang.Long> arlen(byte[] key)
```
    ARLEN Command Returns the length of an array (max index + 1).
    Time complexity: O(1)
    Wire: ARLEN key
    
    Parameters:
    
    key - the name of the key that holds the array
    
    Returns:
    
    a Response that resolves to the array length, or 0 if the key does not exist
    
    Since:
    
    8.0
  - armget
```
@Experimental
Response<java.util.List<byte[]>> armget(byte[] key,
                                                      long... indices)
```
    ARMGET Command Returns the values at multiple indices.
    Time complexity: O(N) where N is the number of requested indices.
    Wire: ARMGET key index1 [index2 ...]
    
    Parameters:
    
    key - the name of the key that holds the array
    
    indices - one or more zero-based indices to retrieve
    
    Returns:
    
    a Response that resolves to the list of values aligned with indices; missing slots appear as null
    
    Since:
    
    8.0
  - armset
```
@Experimental
Response<java.lang.Long> armset(byte[] key,
                                              java.util.Map<java.lang.Long,byte[]> indexValueMap)
```
    ARMSET Command Sets multiple index-value pairs.
    Time complexity: O(N) where N is the number of pairs.
    Wire: ARMSET key index1 value1 [index2 value2 ...]
    
    Parameters:
    
    key - the name of the key that holds the array
    
    indexValueMap - the index-to-value pairs to write
    
    Returns:
    
    a Response that resolves to the number of slots that were previously empty
    
    Since:
    
    8.0
  - arnext
```
@Experimental
Response<java.lang.Long> arnext(byte[] key)
```
    ARNEXT Command Returns the next index that ARINSERT would use.
    Time complexity: O(1)
    Wire: ARNEXT key
    
    Parameters:
    
    key - the name of the key that holds the array
    
    Returns:
    
    a Response that resolves to 0L for missing keys, the next insert index when one is available, or null when the cursor is exhausted
    
    Since:
    
    8.0
  - aropBitwise
```
@Experimental
Response<java.lang.Long> aropBitwise(byte[] key,
                                                   long start,
                                                   long end,
                                                   ArrayBitwise op)
```
    AROP Command Applies a bitwise operation over the non-empty elements in the inclusive [start, end] range.
    Time complexity: O(N) where N is the number of elements scanned.
    Wire: AROP key start end AND|OR|XOR
    
    Parameters:
    
    key - the name of the key that holds the array
    
    start - zero-based start index (inclusive)
    
    end - zero-based end index (inclusive)
    
    op - the bitwise operator to apply
    
    Returns:
    
    a Response that resolves to the operation's numeric result
    
    Since:
    
    8.0
  - aropAggregate
```
@Experimental
Response<byte[]> aropAggregate(byte[] key,
                                             long start,
                                             long end,
                                             ArrayAggregate op)
```
    AROP Command Applies a numeric aggregate over the non-empty elements in the inclusive [start, end] range.
    Time complexity: O(N) where N is the number of elements scanned.
    Wire: AROP key start end SUM|MIN|MAX
    
    Parameters:
    
    key - the name of the key that holds the array
    
    start - zero-based start index (inclusive)
    
    end - zero-based end index (inclusive)
    
    op - the aggregate operator to apply
    
    Returns:
    
    a Response that resolves to the aggregate value as raw bytes, or null when the range is empty
    
    Since:
    
    8.0
  - aropCount
```
@Experimental
Response<java.lang.Long> aropCount(byte[] key,
                                                 long start,
                                                 long end)
```
    AROP Command Counts the number of non-empty elements in the inclusive [start, end] range using the USED subcommand.
    Time complexity: O(N) where N is the number of elements scanned.
    Wire: AROP key start end USED
    
    Parameters:
    
    key - the name of the key that holds the array
    
    start - zero-based start index (inclusive)
    
    end - zero-based end index (inclusive)
    
    Returns:
    
    a Response that resolves to the count of non-empty elements
    
    Since:
    
    8.0
  - aropCount
```
@Experimental
Response<java.lang.Long> aropCount(byte[] key,
                                                 long start,
                                                 long end,
                                                 byte[] match)
```
    AROP Command Counts elements in the inclusive [start, end] range whose value equals match using the MATCH subcommand.
    Time complexity: O(N) where N is the number of elements scanned.
    Wire: AROP key start end MATCH match
    
    Parameters:
    
    key - the name of the key that holds the array
    
    start - zero-based start index (inclusive)
    
    end - zero-based end index (inclusive)
    
    match - the value to match
    
    Returns:
    
    a Response that resolves to the count of matching elements
    
    Since:
    
    8.0
  - arring
```
@Experimental
Response<java.lang.Long> arring(byte[] key,
                                              long size,
                                              byte[]... values)
```
    ARRING Command Inserts one or more values into an array as a fixed-size ring buffer.
    Time complexity: O(N) where N is the number of values inserted.
    Wire: ARRING key size value1 [value2 ...]
    
    Parameters:
    
    key - the name of the key that holds the array
    
    size - the ring buffer window size
    
    values - one or more values to insert
    
    Returns:
    
    a Response that resolves to the last index at which a value was inserted
    
    Since:
    
    8.0
  - arring
```
@Experimental
Response<java.lang.Long> arring(byte[] key,
                                              long size,
                                              byte[] value)
```
    ARRING Command Convenience single-value overload of arring(byte[], long, byte[]...).
    Wire: ARRING key size value
    
    Parameters:
    
    key - the name of the key that holds the array
    
    size - the ring buffer window size
    
    value - the value to insert
    
    Returns:
    
    a Response that resolves to the index at which the value was inserted
    
    Since:
    
    8.0
  - arscan
```
@Experimental
Response<java.util.List<KeyValue<java.lang.Long,byte[]>>> arscan(byte[] key,
                                                                               long start,
                                                                               long end)
```
    ARSCAN Command Iterates existing elements in an inclusive index range and returns the index/value pairs.
    Time complexity: O(N) where N is the number of populated elements.
    Wire: ARSCAN key start end
    
    Parameters:
    
    key - the name of the key that holds the array
    
    start - zero-based start index; when start > end the iteration is reversed
    
    end - zero-based end index (inclusive)
    
    Returns:
    
    a Response that resolves to the populated (index, value) pairs
    
    Since:
    
    8.0
  - arscan
```
@Experimental
Response<java.util.List<KeyValue<java.lang.Long,byte[]>>> arscan(byte[] key,
                                                                               long start,
                                                                               long end,
                                                                               long limit)
```
    ARSCAN Command Iterates existing elements in an inclusive index range with a cap on the number of pairs returned.
    Time complexity: O(N) where N is the number of populated elements returned.
    Wire: ARSCAN key start end LIMIT limit
    
    Parameters:
    
    key - the name of the key that holds the array
    
    start - zero-based start index; when start > end the iteration is reversed
    
    end - zero-based end index (inclusive)
    
    limit - cap on the number of returned populated elements
    
    Returns:
    
    a Response that resolves to the populated (index, value) pairs
    
    Since:
    
    8.0
  - arseek
```
@Experimental
Response<java.lang.Long> arseek(byte[] key,
                                              long index)
```
    ARSEEK Command Sets the insert cursor of an array to a specific index.
    Time complexity: O(1)
    Wire: ARSEEK key index
    
    Parameters:
    
    key - the name of the key that holds the array
    
    index - the zero-based index to set as the new insert cursor
    
    Returns:
    
    a Response that resolves to 1 if the cursor was set, 0 if the key does not exist
    
    Since:
    
    8.0
  - arset
```
@Experimental
Response<java.lang.Long> arset(byte[] key,
                                             long index,
                                             byte[]... values)
```
    ARSET Command Sets one or more contiguous values starting at index.
    Time complexity: O(N) where N is the number of values written.
    Wire: ARSET key index value1 [value2 ...]
    
    Parameters:
    
    key - the name of the key that holds the array
    
    index - zero-based starting index
    
    values - one or more values to write at consecutive indices
    
    Returns:
    
    a Response that resolves to the number of slots that were previously empty
    
    Since:
    
    8.0
  - arset
```
@Experimental
Response<java.lang.Long> arset(byte[] key,
                                             long index,
                                             byte[] value)
```
    ARSET Command Convenience single-value overload of arset(byte[], long, byte[]...).
    Wire: ARSET key index value
    
    Parameters:
    
    key - the name of the key that holds the array
    
    index - zero-based index at which to store the value
    
    value - the value to write
    
    Returns:
    
    a Response that resolves to the number of slots that were previously empty
    
    Since:
    
    8.0

Interface ArrayPipelineBinaryCommands

Method Summary

Method Detail

arcount

ardel

ardel

ardelrange

ardelrange

arget

argetrange

argrep

argrepWithValues

arinfo

arinfoFull

arinsert

arinsert

arlastitems

arlastitems

arlen

armget

armset

arnext

aropBitwise

aropAggregate

aropCount

aropCount

arring

arring

arscan

arscan

arseek

arset

arset