Bancos chave-valor

import { createClient } from "redis";

const redis = await createClient({ url: process.env.REDIS_URL }).connect();
const PLACAR = "placar:semana";

// ZINCRBY é atômico: pontos simultâneos para o mesmo jogador nunca se perdem
const pontuar = (jogador: string, pontos: number) => redis.zIncrBy(PLACAR, pontos, jogador);

const primeiros = (n: number) => redis.zRangeWithScores(PLACAR, 0, n - 1, { REV: true });

// Posição de um jogador, contando do maior para o menor (0 é o primeiro)
const posicao = (jogador: string) => redis.zRevRank(PLACAR, jogador);

await redis.del(PLACAR);
await Promise.all(Array.from({ length: 1000 }, (_, i) => pontuar(`jogador${i % 5}`, (i % 10) + 1)));
console.log("três primeiros:", await primeiros(3));
console.log("posição do jogador0:", (await posicao("jogador0"))! + 1);
await redis.close();

import os
from concurrent.futures import ThreadPoolExecutor

import redis

r = redis.Redis.from_url(os.environ["REDIS_URL"], decode_responses=True)
PLACAR = "placar:semana"


def pontuar(jogador: str, pontos: int) -> float:
    # ZINCRBY é atômico: pontos simultâneos para o mesmo jogador nunca se perdem
    return r.zincrby(PLACAR, pontos, jogador)


def primeiros(n: int) -> list[tuple[str, float]]:
    return r.zrevrange(PLACAR, 0, n - 1, withscores=True)


def posicao(jogador: str) -> int | None:
    return r.zrevrank(PLACAR, jogador)  # 0 é o primeiro


r.delete(PLACAR)
with ThreadPoolExecutor(max_workers=20) as executor:
    list(executor.map(lambda i: pontuar(f"jogador{i % 5}", i % 10 + 1), range(1000)))
print("três primeiros:", primeiros(3))
print("posição do jogador0:", posicao("jogador0") + 1)

package main

import (
	"context"
	"fmt"
	"os"
	"sync"

	"github.com/redis/go-redis/v9"
)

const placar = "placar:semana"

// pontuar usa ZINCRBY, atômico: pontos simultâneos nunca se perdem
func pontuar(ctx context.Context, r *redis.Client, jogador string, pontos float64) error {
	return r.ZIncrBy(ctx, placar, pontos, jogador).Err()
}

func primeiros(ctx context.Context, r *redis.Client, n int64) ([]redis.Z, error) {
	return r.ZRevRangeWithScores(ctx, placar, 0, n-1).Result()
}

// posicao conta do maior para o menor; 0 é o primeiro
func posicao(ctx context.Context, r *redis.Client, jogador string) (int64, error) {
	return r.ZRevRank(ctx, placar, jogador).Result()
}

func main() {
	ctx := context.Background()
	opcoes, err := redis.ParseURL(os.Getenv("REDIS_URL"))
	if err != nil {
		panic(err)
	}
	r := redis.NewClient(opcoes)
	defer r.Close()

	r.Del(ctx, placar)
	var wg sync.WaitGroup
	for i := range 1000 {
		wg.Go(func() { pontuar(ctx, r, fmt.Sprintf("jogador%d", i%5), float64(i%10+1)) })
	}
	wg.Wait()
	top, _ := primeiros(ctx, r, 3)
	fmt.Println("três primeiros:", top)
	p, _ := posicao(ctx, r, "jogador0")
	fmt.Println("posição do jogador0:", p+1)
}

import java.util.List;
import java.util.concurrent.Executors;
import redis.clients.jedis.JedisPooled;
import redis.clients.jedis.resps.Tuple;

public class Placar {
    static final String PLACAR = "placar:semana";
    static final JedisPooled redis = new JedisPooled(System.getenv("REDIS_URL"));

    // ZINCRBY é atômico: pontos simultâneos para o mesmo jogador nunca se perdem
    static double pontuar(String jogador, double pontos) {
        return redis.zincrby(PLACAR, pontos, jogador);
    }

    static List<Tuple> primeiros(int n) {
        return redis.zrevrangeWithScores(PLACAR, 0, n - 1);
    }

    // Posição contando do maior para o menor; 0 é o primeiro
    static Long posicao(String jogador) {
        return redis.zrevrank(PLACAR, jogador);
    }

    public static void main(String[] args) {
        redis.del(PLACAR);
        try (var executor = Executors.newFixedThreadPool(20)) {
            for (int i = 0; i < 1000; i++) {
                int n = i;
                executor.submit(() -> pontuar("jogador" + (n % 5), n % 10 + 1));
            }
        }
        System.out.println("três primeiros: " + primeiros(3));
        System.out.println("posição do jogador0: " + (posicao("jogador0") + 1));
    }
}

using StackExchange.Redis;

var url = Environment.GetEnvironmentVariable("REDIS_URL")!;
var conexao = await ConnectionMultiplexer.ConnectAsync(url);
var redis = conexao.GetDatabase();
const string Placar = "placar:semana";

// ZINCRBY é atômico: pontos simultâneos para o mesmo jogador nunca se perdem
Task<double> Pontuar(string jogador, double pontos) =>
    redis.SortedSetIncrementAsync(Placar, jogador, pontos);

Task<SortedSetEntry[]> Primeiros(int n) =>
    redis.SortedSetRangeByRankWithScoresAsync(Placar, 0, n - 1, Order.Descending);

// Posição contando do maior para o menor; 0 é o primeiro
Task<long?> Posicao(string jogador) =>
    redis.SortedSetRankAsync(Placar, jogador, Order.Descending);

await redis.KeyDeleteAsync(Placar);
await Task.WhenAll(
    Enumerable.Range(0, 1000).Select(i => Pontuar($"jogador{i % 5}", i % 10 + 1)));
Console.WriteLine("três primeiros: " + string.Join(", ", await Primeiros(3)));
Console.WriteLine($"posição do jogador0: {await Posicao("jogador0") + 1}");