Redis Iris

Redis install Data types

Tools Community Docs

Login Sign up

Develop with Redis Libraries and tools Redis products

Commands

Download documentation

Choose the products and versions you want. Everything arrives as one .tar.gz, with a directory per product.

Format

This page

	Products	Version
	Develop with Redis Clients, data types, programmability, and Redis for AI. RedisVL is listed separately.
	Libraries and tools Client libraries, observability, and cloud integrations. Redis Data Integration is listed separately.
	RedisVL
	Redis Software
	Redis Cloud
	Redis for Kubernetes
	Redis Open Source
	Redis Iris context engine
	Redis Feature Form
	Redis Insight
	Redis Data Integration
	Glossary
	Command reference

LMOVE

Syntax text Syntax diagram API methods

LMOVE source destination <LEFT | RIGHT> <LEFT | RIGHT>

Client:

lmove(
    first_list: str,
    second_list: str,
    src: str = "LEFT",
    dest: str = "RIGHT"
) → ResponseT

Possible errors

ERR syntax error: ResponseError

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    source: RedisKey,
    destination: RedisKey,
    left: "LEFT",
    right: "RIGHT",
    callback?: Callback<string>
) → Result<string, Context>

lmove(
    source: RedisKey,
    destination: RedisKey,
    right: "RIGHT",
    left: "LEFT",
    callback?: Callback<string>
) → Result<string, Context>

lmove(
    source: RedisKey,
    destination: RedisKey,
    right: "RIGHT",
    right1: "RIGHT",
    callback?: Callback<string>
) → Result<string, Context>

Possible errors

ERR syntax error: ReplyError

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    srcKey: String,
    dstKey: String,
    to: ListDirection from final ListDirection  // can be LEFT or RIGHT
) → String  // The element being popped and pushed

lmove(
    srcKey: String,
    dstKey: String,
    from: ListDirection,  // can be LEFT or RIGHT
    to: ListDirection  // can be LEFT or RIGHT
) → String  // The element being popped and pushed

Possible errors

ERR syntax error: JedisDataException

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    source: K,  // the source key.
    destination: K,  // the destination type: key.
    args: LMoveArgs  // command arguments to configure source and destination directions.
) → V  // V bulk-string-reply the element being popped and pushed. @since 6.1

Possible errors

ERR syntax error: RedisCommandExecutionException

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    source: K,  // the source key.
    destination: K,  // the destination type: key.
    args: LMoveArgs  // command arguments to configure source and destination directions.
) → RedisFuture<V>  // V bulk-string-reply the element being popped and pushed. @since 6.1

Possible errors

ERR syntax error: RedisCommandExecutionException

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    source: K,  // the source key.
    destination: K,  // the destination type: key.
    args: LMoveArgs  // command arguments to configure source and destination directions.
) → Mono<V>  // V bulk-string-reply the element being popped and pushed. @since 6.1

Possible errors

ERR syntax error: RedisCommandExecutionException

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

LMove(
    ctx: context.Context,
    source: Any,
    destination: Any,
    srcpos: Any,
    destpos: string
) → *StringCmd

Possible errors

ERR syntax error: redis.Error

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

ListMove(
    sourceKey: RedisKey,  // The key of the list to remove from.
    destinationKey: RedisKey,  // The key of the list to move to.
    sourceSide: ListSide,  // What side of the sourceKey list to remove from.
    destinationSide: ListSide,  // What side of the destinationKey list to move to.
    flags: CommandFlags  // The flags to use for this operation.
) → RedisValue  // The element being popped and pushed or Null if there is no element to move.

ListMove(
    sourceKey: RedisKey,  // The key of the list to remove from.
    destinationKey: RedisKey,  // The key of the list to move to.
    sourceSide: ListSide,  // What side of the sourceKey list to remove from.
    destinationSide: ListSide,  // What side of the destinationKey list to move to.
    flags: CommandFlags  // The flags to use for this operation.
) → RedisValue  // The element being popped and pushed or Null if there is no element to move.

Possible errors

ERR syntax error: RedisServerException

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

ListMoveAsync(
    sourceKey: RedisKey,  // The key of the list to remove from.
    destinationKey: RedisKey,  // The key of the list to move to.
    sourceSide: ListSide,  // What side of the sourceKey list to remove from.
    destinationSide: ListSide,  // What side of the destinationKey list to move to.
    flags: CommandFlags  // The flags to use for this operation.
) → Task<RedisValue>  // The element being popped and pushed or Null if there is no element to move.

ListMoveAsync(
    sourceKey: RedisKey,  // The key of the list to remove from.
    destinationKey: RedisKey,  // The key of the list to move to.
    sourceSide: ListSide,  // What side of the sourceKey list to remove from.
    destinationSide: ListSide,  // What side of the destinationKey list to move to.
    flags: CommandFlags  // The flags to use for this operation.
) → Task<RedisValue>  // The element being popped and pushed or Null if there is no element to move.

Possible errors

ERR syntax error: RedisServerException

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    $source: string,
    $destination: string,
    $where: string,
    $to: string
) → string

Possible errors

ERR syntax error: Predis\Response\ServerException

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    source: String,  // source key
    destination: String,  // destination key
    where_source: String, Symbol,  // LEFT or RIGHT
    where_destination: String, Symbol  // LEFT or RIGHT
) → nil, String  // the element, or nil when the source key does not exist

Possible errors

ERR syntax error: Redis::CommandError

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    srckey: S,
    dstkey: D,
    src_dir: Direction,
    dst_dir: Direction
) → (String)

Possible errors

ERR syntax error: ErrorKind::Server(ServerErrorKind::ResponseError)

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

lmove(
    srckey: S,
    dstkey: D,
    src_dir: Direction,
    dst_dir: Direction
) → (String)

Possible errors

ERR syntax error: ErrorKind::Server(ServerErrorKind::ResponseError)

See Redis error messages for what each error means. Other errors, such as connection errors, aren't listed.

Available since:: Redis Open Source 6.2.0
Time complexity:: O(1)
ACL categories:: @write, @list, @slow,
Compatibility:: Redis Software and Redis Cloud compatibility

Note:

This command's behavior varies in clustered Redis environments. See the multi-key operations page for more information.

Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination.

For example: consider source holding the list a,b,c, and destination holding the list x,y,z. Executing LMOVE source destination RIGHT LEFT results in source holding a,b and destination holding c,x,y,z.

If source does not exist, the value nil is returned and no operation is performed. If source and destination are the same, the operation is equivalent to removing the first/last element from the list and pushing it as first/last element of the list, so it can be considered as a list rotation command (or a no-op if wherefrom is the same as whereto).

This command comes in place of the now deprecated RPOPLPUSH. Doing LMOVE RIGHT LEFT is equivalent.

Required arguments

source

The key of the source list.

destination

The key of the destination list.

LEFT | RIGHT

The end of source to pop the element from: LEFT (head) or RIGHT (tail).

LEFT | RIGHT

The end of destination to push the element to: LEFT (head) or RIGHT (tail).

Examples

redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LMOVE mylist myotherlist RIGHT LEFT
"three"
redis> LMOVE mylist myotherlist LEFT RIGHT
"one"
redis> LRANGE mylist 0 -1
1) "two"
redis> LRANGE myotherlist 0 -1
1) "three"
2) "one"

Details

Pattern: reliable queue

Redis is often used as a messaging server to implement processing of background jobs or other kinds of messaging tasks. A simple form of queue is often obtained pushing values into a list in the producer side, and waiting for this values in the consumer side using RPOP (using polling), or BRPOP if the client is better served by a blocking operation.

However in this context the obtained queue is not reliable as messages can be lost, for example in the case there is a network problem or if the consumer crashes just after the message is received but it is still to process.

LMOVE (or BLMOVE for the blocking variant) offers a way to avoid this problem: the consumer fetches the message and at the same time pushes it into a processing list. It will use the LREM command in order to remove the message from the processing list once the message has been processed.

An additional client may monitor the processing list for items that remain there for too much time, and will push those timed out items into the queue again if needed.

Pattern: circular list

Using LMOVE with the same source and destination key, a client can visit all the elements of an N-elements list, one after the other, in O(N) without transferring the full list from the server to the client using a single LRANGE operation.

The above pattern works even in the following conditions:

There are multiple clients rotating the list: they'll fetch different elements, until all the elements of the list are visited, and the process restarts.
Even if other clients are actively pushing new items at the end of the list.

The above makes it very simple to implement a system where a set of items must be processed by N workers continuously as fast as possible. An example is a monitoring system that must check that a set of web sites are reachable, with the smallest delay possible, using a number of parallel workers.

Note that this implementation of workers is trivially scalable and reliable, because even if a message is lost the item is still in the queue and will be processed at the next iteration.

Redis Software and Redis Cloud compatibility

Redis Software	Redis Cloud	Notes
✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Return information

RESP2 RESP3

Bulk string reply: the element being popped and pushed.