Redis Datentypen Erklärt: Wann und wie man sie verwendet

Gängige Redis-Datentypen

Strings

Strings in Redis sind ein grundlegender Datentyp, der zum Speichern und Abrufen von String-Werten verwendet wird.

Anwendungsfälle: Geeignet zum Speichern von Text oder Zahlen, wie z. B. Benutzernamen, E-Mail-Adressen oder Seitenzählern. Strings können auch binäre Daten speichern, was sie ideal zum Speichern von Bildern oder serialisierten Objekten macht.
Vorteile: Einfache Operationen mit atomaren Aktionen wie Inkrementieren (INCR).

// Save a string
let _: () = conn.set("username", "alice").await.unwrap();

// Retrieve a string
let username: String = conn.get("username").await.unwrap();

Listen

Redis-Listen sind Sammlungen von Strings, die nach Einfügereihenfolge sortiert sind.

Anwendungsfälle: Ideal für die Implementierung von Message Queues, Aktivitätsprotokollen oder Listen kürzlich aufgerufener Elemente. Listen unterstützen das Hinzufügen oder Entfernen von Elementen von beiden Enden und können als Stacks oder Queues verwendet werden.
Vorteile: Schnelle Einfüge- und Löschoperationen. Geeignet für FIFO-Queues (First-In-First-Out) oder LIFO-Stacks (Last-In-First-Out).

// Add elements to the head of a list
let _: () = conn.lpush("events", "login").await.unwrap();
let _: () = conn.lpush("events", "logout").await.unwrap();

// Retrieve list elements
let events: Vec<String> = conn.lrange("events", 0, -1).await.unwrap();

Sets

Sets sind ungeordnete Sammlungen eindeutiger Strings.

Anwendungsfälle: Ideal zum Speichern eindeutiger Elemente ohne eine bestimmte Reihenfolge, wie z. B. Tags, besuchte IP-Adressen oder Freundeslisten in einem sozialen Netzwerk.
Vorteile: Schnelle Operationen zum Hinzufügen, Löschen und Überprüfen der Existenz von Elementen. Unterstützt Set-Operationen wie Vereinigung, Schnittmenge und Differenz.

// Add elements to a set
let _: () = conn.sadd("tags", "redis").await.unwrap();
let _: () = conn.sadd("tags", "database").await.unwrap();

// Retrieve all set members
let tags: Vec<String> = conn.smembers("tags").await.unwrap();

Sorted Sets

Sortierte Sets ähneln Sets, ordnen aber jedem Member eine Bewertung zu.

Anwendungsfälle: Geeignet zum Speichern von Daten, die nach Bewertung sortiert werden müssen, wie z. B. Leaderboards, Prioritätswarteschlangen oder Daten mit gewichteter Sortierung.
Vorteile: Neben grundlegenden Set-Operationen unterstützt es das Abrufen von Elementen nach Bewertung oder lexikalischer Reihenfolge und das Abrufen von Elementen innerhalb bestimmter Bereiche.

// Add elements to a sorted set
let _: () = conn.zadd("leaderboard", "alice", 100).await.unwrap();
let _: () = conn.zadd("leaderboard", "bob", 200).await.unwrap();

// Retrieve sorted set elements
let leaderboard: Vec<(String, f64)> = conn.zrange_withscores("leaderboard", 0, -1).await.unwrap();

Hashes

Hashes sind Sammlungen von Schlüssel-Wert-Paaren, ähnlich wie Dictionaries oder Objekte in Programmiersprachen.

Anwendungsfälle: Ideal zum Speichern von Objekten oder mehreren zusammengehörigen Datenpunkten, wie z. B. Benutzerattributen (Name, Alter, E-Mail usw.).
Vorteile: Effizient zum gleichzeitigen Lesen oder Schreiben mehrerer Felder, wodurch es sich zur Darstellung von Objekten oder zum Aggregieren von Datenpunkten eignet.

// Add key-value pairs to a hash
let _: () = conn.hset("user:100", "email", "alice@example.com").await.unwrap();

// Retrieve all key-value pairs from the hash
let user_info: HashMap<String, String> = conn.hgetall("user:100").await.unwrap();

Bitmaps

Bitmaps sind Arrays von Bits, bei denen jedes Bit unabhängig gesetzt oder abgefragt werden kann.

Anwendungsfälle: Ideal für Szenarien, die das Markieren der Existenz erfordern, wie z. B. Benutzeranmeldungen oder das Umschalten von Feature-Status.
Vorteile: Sehr platzsparend für die Handhabung großer Mengen boolescher Werte.

// Set a bit in the bitmap
let _: () = conn.setbit("features", 0, true).await.unwrap();  // Enable feature 0

// Retrieve the value of a bit
let feature_enabled: bool = conn.getbit("features", 0).await.unwrap();

HyperLogLogs

HyperLogLog ist eine probabilistische Datenstruktur, die zur effizienten Schätzung der Kardinalität (der Anzahl eindeutiger Elemente) verwendet wird.

Anwendungsfälle: Ideal zum Schätzen eindeutiger Zählungen in großen Datensätzen, wie z. B. eindeutige Website-Besucher.
Vorteile: Extrem speichereffizient im Vergleich zu herkömmlichen Zählmethoden, insbesondere bei der Verarbeitung großer Datensätze.

// Add elements to a HyperLogLog
let _: () = conn.pfadd("pageviews", "user1").await.unwrap();
let _: () = conn.pfadd("pageviews", "user2").await.unwrap();

// Retrieve the approximate cardinality
let unique_pageviews: i64 = conn.pfcount("pageviews").await.unwrap();

Auswahl von Datentypen

Die Auswahl des geeigneten Redis-Datentyps für Backend-Operationen ist entscheidend, um eine optimale Speicher- und Abrufeffizienz zu erzielen. Das Verständnis Ihrer Datenstruktur und Ihres Anwendungsfalls ist der Schlüssel. Nachfolgend sind gängige Backend-Szenarien mit empfohlenen Redis-Datentypen aufgeführt:

Benutzersitzungen

Empfohlener Typ: Hash
Grund: Hashes können mehrere Eigenschaften eines Benutzersitzungsobjekts speichern (z. B. Benutzer-ID, Token, letzte Zugriffszeit) und ermöglichen individuelle Aktualisierungen oder Abrufe.

let _: () = conn.hset("session:userid", "token", "abc123").await.unwrap();
let _: () = conn.hset("session:userid", "last_access", "2023-01-01").await.unwrap();

Echtzeit-Messaging oder Event Queuing

Empfohlener Typ: Liste
Grund: Listen bieten FIFO-Queue-Eigenschaften, die für Echtzeit-Messaging oder Task Queues geeignet sind.

let _: () = conn.rpush("events_queue", "event1").await.unwrap();
let event: String = conn.lpop("events_queue").await.unwrap();

Zugriffszähler oder Ratenbegrenzung

Empfohlener Typ: String
Grund: Strings unterstützen atomare Inkrementierungsoperationen, ideal für Zähler.

let _: () = conn.incr("page_view_count", 1).await.unwrap();
let count: i64 = conn.get("page_view_count").await.unwrap();

Leaderboards oder Score Sorting

Empfohlener Typ: Sorted Set
Grund: Sortierte Sets sortieren Daten automatisch basierend auf Bewertungen, perfekt für Leaderboards oder alle sortierten Daten.

let _: () = conn.zadd("leaderboard", "user123", 2500).await.unwrap();
let leaderboard: Vec<(String, f64)> = conn.zrange_withscores("leaderboard", 0, -1).await.unwrap();

Eindeutige Wertsammlungen wie Tags oder Kategorien

Empfohlener Typ: Set
Grund: Sets bieten eine eindeutige Wertspeicherung, die sich für Deduplizierungsszenarien eignet.

let _: () = conn.sadd("tags", "redis").await.unwrap();
let tags: Vec<String> = conn.smembers("tags").await.unwrap();

Multi-Attribut-Objektspeicherung

Empfohlener Typ: Hash
Grund: Hashes können mehrere Felder eines Objekts speichern und ermöglichen unabhängigen Zugriff oder Aktualisierungen.

let _: () = conn.hset("user:100", "name", "Alice").await.unwrap();
let user: HashMap<String, String> = conn.hgetall("user:100").await.unwrap();

Feature Flags oder Toggles

Empfohlener Typ: Bitmap
Grund: Bitmaps sind ideal zum Speichern boolescher Zustände wie Feature-Toggles.

let _: () = conn.setbit("features", 1, true).await.unwrap();
let feature_on: bool = conn.getbit("features", 1).await.unwrap();

Fazit

Die Wahl des richtigen Typs hängt von Ihren spezifischen Bedürfnissen ab. Wenn Ihre Datenstruktur einfach ist (wie ein einzelnes Schlüssel-Wert-Paar), kann ein String ausreichen. Für komplexere Strukturen, wie Benutzerprofile oder Sitzungsinformationen, sind Hashes möglicherweise besser geeignet. Wenn Ihre Anwendung Leaderboards oder sortierte Daten enthält, verwenden Sie entsprechend sortierte Sätze.

Wir sind Leapcell, Ihre erste Wahl für das Hosting von Backend-Projekten, mit einem integrierten serverlosen Redis.

Leapcell ist die Serverless-Plattform der nächsten Generation für Webhosting, asynchrone Tasks und Redis:

Multi-Language Support

Entwickeln Sie mit Node.js, Python, Go oder Rust.

Unbegrenzt viele Projekte kostenlos bereitstellen

Zahlen Sie nur für die Nutzung - keine Anfragen, keine Gebühren.

Unschlagbare Kosteneffizienz

Pay-as-you-go ohne Leerlaufgebühren.
Beispiel: 25 $ unterstützen 6,94 Millionen Anfragen bei einer durchschnittlichen Antwortzeit von 60 ms.

Optimierte Entwicklererfahrung

Intuitive Benutzeroberfläche für mühelose Einrichtung.
Vollständig automatisierte CI/CD-Pipelines und GitOps-Integration.
Echtzeit-Metriken und -Protokollierung für verwertbare Einblicke.

Mühelose Skalierbarkeit und hohe Leistung

Automatische Skalierung zur einfachen Bewältigung hoher Parallelität.
Null Betriebsaufwand - konzentrieren Sie sich einfach auf das Bauen.

Erfahren Sie mehr in der Dokumentation!

Folgen Sie uns auf X: @LeapcellHQ