Redis arrays

res1 = r.arset("events:1", 0, "login", "click", "purchase")
print(res1)
# >>> 3

res2 = r.arget("events:1", 0)
print(res2)
# >>> login

res3 = r.arget("events:1", 999)
print(res3)
# >>> None

const setResult = await client.arSet('events:1', 0, ['login', 'click', 'purchase']);
console.log(setResult); // >>> 3

const getResult = await client.arGet('events:1', 0);
console.log(getResult); // >>> login

const missingResult = await client.arGet('events:1', 999);
console.log(missingResult); // >>> null

            CompletableFuture<Void> arsetArgetExample = asyncCommands
                    .arset("events:1", 0, "login", "click", "purchase")
                    .thenCompose(res1 -> {
                        System.out.println(res1);
                        // >>> 3
                        return asyncCommands.arget("events:1", 0);
                    })
                    .thenCompose(res2 -> {
                        System.out.println(res2);
                        // >>> login
                        return asyncCommands.arget("events:1", 999);
                    })
                    .thenAccept(res3 -> {
                        System.out.println(res3);
                        // >>> null
                    })
                    .toCompletableFuture();

            arsetArgetExample.join();

            Mono<Long> arsetArget1 = reactiveCommands.arset("events:1", 0, "login", "click", "purchase")
                    .doOnNext(result -> {
                        System.out.println(result); // >>> 3
                    });

            arsetArget1.block();

            Mono<String> arsetArget2 = reactiveCommands.arget("events:1", 0).doOnNext(result -> {
                System.out.println(result); // >>> login
            });

            arsetArget2.block();

            Mono<Optional<String>> arsetArget3 = reactiveCommands.arget("events:1", 999)
                    .map(Optional::of)
                    .defaultIfEmpty(Optional.empty())
                    .doOnNext(result -> {
                        System.out.println(result.orElse(null)); // >>> null
                    });

            arsetArget3.block();

	setRes, err := rdb.ARSet(ctx, "events:1", 0, "login", "click", "purchase").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(setRes) // >>> 3

	getRes, err := rdb.ARGet(ctx, "events:1", 0).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(getRes) // >>> login

	missing, err := rdb.ARGet(ctx, "events:1", 999).Result()

	if err == redis.Nil {
		fmt.Println("<nil>") // >>> <nil>
	} else if err != nil {
		panic(err)
	} else {
		fmt.Println(missing)
	}

        $res1 = $redis->arset('events:1', 0, ['login', 'click', 'purchase']);
        echo $res1 . PHP_EOL; // >>> 3

        $res2 = $redis->arget('events:1', 0);
        echo $res2 . PHP_EOL; // >>> login

        $res3 = $redis->arget('events:1', 999);
        echo var_export($res3, true) . PHP_EOL; // >>> NULL

res4 = r.armset("metrics", {0: "10", 5: "20", 100: "30"})
print(res4)
# >>> 3

res5 = r.armget("metrics", 0, 5, 100, 999)
print(res5)
# >>> ['10', '20', '30', None]

const mSetResult = await client.arMSet('metrics', { 0: '10', 5: '20', 100: '30' });
console.log(mSetResult); // >>> 3

const mGetResult = await client.arMGet('metrics', [0, 5, 100, 999]);
console.log(mGetResult); // >>> [ '10', '20', '30', null ]

            Map<Long, String> metricsValues = new HashMap<>();
            metricsValues.put(0L, "10");
            metricsValues.put(5L, "20");
            metricsValues.put(100L, "30");

            CompletableFuture<Void> armsetArmgetExample = asyncCommands
                    .armset("metrics", metricsValues)
                    .thenCompose(res1 -> {
                        System.out.println(res1);
                        // >>> 3
                        return asyncCommands.armget("metrics", 0, 5, 100, 999);
                    })
                    .thenAccept(res2 -> {
                        System.out.println(res2);
                        // >>> [10, 20, 30, null]
                    })
                    .toCompletableFuture();

            armsetArmgetExample.join();

            Map<Long, String> armsetParams = new HashMap<>();
            armsetParams.put(0L, "10");
            armsetParams.put(5L, "20");
            armsetParams.put(100L, "30");

            Mono<Long> armsetArmget1 = reactiveCommands.armset("metrics", armsetParams).doOnNext(result -> {
                System.out.println(result); // >>> 3
            });

            armsetArmget1.block();

            Mono<List<String>> armsetArmget2 = reactiveCommands.armget("metrics", 0, 5, 100, 999)
                    .collectList()
                    .map(values -> values.stream()
                            .map(value -> value.getValueOrElse(null))
                            .collect(Collectors.toList()))
                    .doOnNext(result -> {
                        System.out.println(result); // >>> [10, 20, 30, null]
                    });

            armsetArmget2.block();

	msetRes, err := rdb.ARMSet(ctx, "metrics",
		redis.AREntry{Index: 0, Value: "10"},
		redis.AREntry{Index: 5, Value: "20"},
		redis.AREntry{Index: 100, Value: "30"},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(msetRes) // >>> 3

	mgetRes, err := rdb.ARMGet(ctx, "metrics", 0, 5, 100, 999).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(mgetRes) // >>> [10 20 30 <nil>]

        $res1 = $redis->armset('metrics', [0 => '10', 5 => '20', 100 => '30']);
        echo $res1 . PHP_EOL; // >>> 3

        $res2 = $redis->armget('metrics', [0, 5, 100, 999]);
        echo json_encode($res2) . PHP_EOL; // >>> ["10","20","30",null]

res6 = r.arset("sparse", 0, "a")
print(res6)
# >>> 1

res7 = r.arset("sparse", 1000000, "b")
print(res7)
# >>> 1

res8 = r.arlen("sparse")
print(res8)
# >>> 1000001

res9 = r.arcount("sparse")
print(res9)
# >>> 2

const setA = await client.arSet('sparse', 0, 'a');
console.log(setA); // >>> 1

const setB = await client.arSet('sparse', 1000000, 'b');
console.log(setB); // >>> 1

const lenResult = await client.arLen('sparse');
console.log(lenResult); // >>> 1000001

const countResult = await client.arCount('sparse');
console.log(countResult); // >>> 2

            CompletableFuture<Void> lenCountExample = asyncCommands
                    .arset("sparse", 0, "a")
                    .thenCompose(res1 -> {
                        System.out.println(res1);
                        // >>> 1
                        return asyncCommands.arset("sparse", 1000000, "b");
                    })
                    .thenCompose(res2 -> {
                        System.out.println(res2);
                        // >>> 1
                        return asyncCommands.arlen("sparse");
                    })
                    .thenCompose(res3 -> {
                        System.out.println(res3);
                        // >>> 1000001
                        return asyncCommands.arcount("sparse");
                    })
                    .thenAccept(res4 -> {
                        System.out.println(res4);
                        // >>> 2
                    })
                    .toCompletableFuture();

            lenCountExample.join();

            Mono<Long> lenCount1 = reactiveCommands.arset("sparse", 0, "a").doOnNext(result -> {
                System.out.println(result); // >>> 1
            });

            lenCount1.block();

            Mono<Long> lenCount2 = reactiveCommands.arset("sparse", 1000000, "b").doOnNext(result -> {
                System.out.println(result); // >>> 1
            });

            lenCount2.block();

            Mono<Long> lenCount3 = reactiveCommands.arlen("sparse").doOnNext(result -> {
                System.out.println(result); // >>> 1000001
            });

            lenCount3.block();

            Mono<Long> lenCount4 = reactiveCommands.arcount("sparse").doOnNext(result -> {
                System.out.println(result); // >>> 2
            });

            lenCount4.block();

	set1, err := rdb.ARSet(ctx, "sparse", 0, "a").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(set1) // >>> 1

	set2, err := rdb.ARSet(ctx, "sparse", 1000000, "b").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(set2) // >>> 1

	lenRes, err := rdb.ARLen(ctx, "sparse").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(lenRes) // >>> 1000001

	countRes, err := rdb.ARCount(ctx, "sparse").Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(countRes) // >>> 2

        $res1 = $redis->arset('sparse', 0, 'a');
        echo $res1 . PHP_EOL; // >>> 1

        $res2 = $redis->arset('sparse', 1000000, 'b');
        echo $res2 . PHP_EOL; // >>> 1

        $res3 = $redis->arlen('sparse');
        echo $res3 . PHP_EOL; // >>> 1000001

        $res4 = $redis->arcount('sparse');
        echo $res4 . PHP_EOL; // >>> 2

res10 = r.armset("seq", {0: "a", 1: "b", 3: "d"})
print(res10)
# >>> 3

res11 = r.argetrange("seq", 0, 3)
print(res11)
# >>> ['a', 'b', None, 'd']

const rangeSetResult = await client.arMSet('seq', { 0: 'a', 1: 'b', 3: 'd' });
console.log(rangeSetResult); // >>> 3

const rangeResult = await client.arGetRange('seq', 0, 3);
console.log(rangeResult); // >>> [ 'a', 'b', null, 'd' ]

            Map<Long, String> seqRangeValues = new HashMap<>();
            seqRangeValues.put(0L, "a");
            seqRangeValues.put(1L, "b");
            seqRangeValues.put(3L, "d");

            CompletableFuture<Void> argetrangeExample = asyncCommands
                    .armset("seq", seqRangeValues)
                    .thenCompose(res1 -> {
                        System.out.println(res1);
                        // >>> 3
                        return asyncCommands.argetrange("seq", 0, 3);
                    })
                    .thenAccept(res2 -> {
                        System.out.println(res2);
                        // >>> [a, b, null, d]
                    })
                    .toCompletableFuture();

            argetrangeExample.join();

            Map<Long, String> argetrangeParams = new HashMap<>();
            argetrangeParams.put(0L, "a");
            argetrangeParams.put(1L, "b");
            argetrangeParams.put(3L, "d");

            Mono<Long> argetrange1 = reactiveCommands.armset("seq", argetrangeParams).doOnNext(result -> {
                System.out.println(result); // >>> 3
            });

            argetrange1.block();

            Mono<List<String>> argetrange2 = reactiveCommands.argetrange("seq", 0, 3)
                    .collectList()
                    .map(values -> values.stream()
                            .map(value -> value.getValueOrElse(null))
                            .collect(Collectors.toList()))
                    .doOnNext(result -> {
                        System.out.println(result); // >>> [a, b, null, d]
                    });

            argetrange2.block();

	msetRes, err := rdb.ARMSet(ctx, "seq",
		redis.AREntry{Index: 0, Value: "a"},
		redis.AREntry{Index: 1, Value: "b"},
		redis.AREntry{Index: 3, Value: "d"},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(msetRes) // >>> 3

	rangeRes, err := rdb.ARGetRange(ctx, "seq", 0, 3).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(rangeRes) // >>> [a b <nil> d]

        $res1 = $redis->armset('seq', [0 => 'a', 1 => 'b', 3 => 'd']);
        echo $res1 . PHP_EOL; // >>> 3

        $res2 = $redis->argetrange('seq', 0, 3);
        echo json_encode($res2) . PHP_EOL; // >>> ["a","b",null,"d"]

res12 = r.armset("seq", {0: "a", 1: "b", 3: "d"})
print(res12)
# >>> 3

res13 = r.arscan("seq", 0, 3)
for index, value in res13:
    print(f"{index} -> {value}")
# >>> 0 -> a
# >>> 1 -> b
# >>> 3 -> d

const scanSetResult = await client.arMSet('seq', { 0: 'a', 1: 'b', 3: 'd' });
console.log(scanSetResult); // >>> 3

const scanResult = await client.arScan('seq', 0, 3);
for (const { index, value } of scanResult) {
  console.log(`${index} -> ${value}`);
}
// >>> 0 -> a
// >>> 1 -> b
// >>> 3 -> d

            Map<Long, String> seqScanValues = new HashMap<>();
            seqScanValues.put(0L, "a");
            seqScanValues.put(1L, "b");
            seqScanValues.put(3L, "d");

            CompletableFuture<Void> arscanExample = asyncCommands
                    .armset("seq", seqScanValues)
                    .thenCompose(res1 -> {
                        System.out.println(res1);
                        // >>> 3
                        return asyncCommands.arscan("seq", 0, 3);
                    })
                    .thenAccept(res2 -> {
                        for (IndexedValue<String> pair : res2) {
                            System.out.println(pair.getIndex() + " -> " + pair.getValue());
                        }
                        // >>> 0 -> a
                        // >>> 1 -> b
                        // >>> 3 -> d
                    })
                    .toCompletableFuture();

            arscanExample.join();

            Map<Long, String> arscanParams = new HashMap<>();
            arscanParams.put(0L, "a");
            arscanParams.put(1L, "b");
            arscanParams.put(3L, "d");

            Mono<Long> arscan1 = reactiveCommands.armset("seq", arscanParams).doOnNext(result -> {
                System.out.println(result); // >>> 3
            });

            arscan1.block();

            Mono<List<IndexedValue<String>>> arscan2 = reactiveCommands.arscan("seq", 0, 3)
                    .doOnNext(entry -> {
                        System.out.println(entry.getIndex() + " -> " + entry.getValue());
                        // >>> 0 -> a
                        // >>> 1 -> b
                        // >>> 3 -> d
                    })
                    .collectList()
            ;

            arscan2.block();

	msetRes, err := rdb.ARMSet(ctx, "seq",
		redis.AREntry{Index: 0, Value: "a"},
		redis.AREntry{Index: 1, Value: "b"},
		redis.AREntry{Index: 3, Value: "d"},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(msetRes) // >>> 3

	scanRes, err := rdb.ARScan(ctx, "seq", 0, 3, nil).Result()

	if err != nil {
		panic(err)
	}

	for _, entry := range scanRes {
		fmt.Printf("%d -> %s\n", entry.Index, entry.Value)
	}
	// >>> 0 -> a
	// >>> 1 -> b
	// >>> 3 -> d

        $res1 = $redis->armset('seq', [0 => 'a', 1 => 'b', 3 => 'd']);
        echo $res1 . PHP_EOL; // >>> 3

        $res2 = $redis->arscan('seq', 0, 3);
        foreach ($res2 as $pair) {
            echo $pair[0] . ' -> ' . $pair[1] . PHP_EOL;
        }
        // >>> 0 -> a
        // >>> 1 -> b
        // >>> 3 -> d

res14 = r.arinsert("log", "event1")
print(res14)
# >>> 0

res15 = r.arinsert("log", "event2")
print(res15)
# >>> 1

res16 = r.arnext("log")
print(res16)
# >>> 2

res17 = r.arseek("log", 10)
print(res17)
# >>> 1

res18 = r.arinsert("log", "event3")
print(res18)
# >>> 10