Scenario Overview

Imagine an application that logs temperature readings for different cities. Each entry contains the date and time, temperature, and city name. Our goal is to utilize Redis to ensure that the most recent records for each city appear first in the list.

Dependencies and Docker Configuration

To facilitate our project, we have included several important Rust dependencies. Below are the key dependencies:

[dependencies]

redis = "0.23.3"

chrono = { version = "0.4", features = ["serde"] }

serde = { version = "1.0", features = [] }

serde_derive = "1.0"

serde_json = "1.0"

The redis crate is crucial for interacting with the Redis data store, while chrono provides functionalities for handling date and time. The serde family of crates—serde, serde_derive, and serde_json—ensures seamless serialization and deserialization of JSON data within our application.

To test our infrastructure, we've set up a Docker Compose configuration, which is as follows:

version: '3'

services:

redis:

image: redis:latest

ports:

• "6379:6379"

This configuration launches a Redis service utilizing the latest Redis image, mapping the default Redis port (6379) to the host, allowing our application to communicate with the Redis instance effortlessly.

Data Structure

The JSON format for each record is structured as follows:

{

"current_date": "2023-05-01T15:04:05Z07:00",

"temperature": "25",

"city": "New York"

}

Utilizing LPUSH in Rust

We will leverage the redis crate to interact with Redis. First, let's define a WeatherData struct to represent our data and a function to store this data in Redis using the LPUSH command.

/// Represents weather data for a specific city and date-time.

#[derive(Serialize, Deserialize, Debug)]

struct WeatherData {

/// The date and time the data was recorded.

current_date: NaiveDateTime,

/// The recorded temperature.

temperature: String,

/// The city for which the data was recorded.

city: String,

}

/// Saves weather data to a Redis database.

///

/// The data is stored in a list associated with the city name.

///

/// # Arguments

///

/// * conn - A mutable Redis connection.

/// * data - The weather data to save.

///

/// # Returns

///

/// A result indicating success or a Redis error.

fn save_weather_data(conn: &mut Connection, data: &WeatherData) -> redis::RedisResult<()> {

let key = &data.city;

let value = to_string(data).unwrap();

conn.lpush(key, value)

}

The save_weather_data function accepts a Redis connection and an instance of WeatherData. It serializes the WeatherData struct into a JSON format and uses the lpush method to prepend the JSON string to the list, employing the city name as the key.

Storing Data in Reverse Chronological Order

Since the LPUSH command adds elements to the beginning of the list, this guarantees that the latest entries will always appear first, thus preserving a chronological descending order.

Redis lists are ordered collections of string elements, organized based on the order in which they are added. This structure employs a linked list, allowing for quick insertions and removals at both ends of the list.

Retrieving Data in Chronological Descending Order

To extract records in the desired order, we will create a function that retrieves the entries for a specified city using the lrange command. This command, with the parameters 0 to -1, indicates fetching all elements from the start to the end of the list.

The get_weather_data function retrieves all records for a designated city, returning them as a vector of WeatherData structs. Since Redis already maintains the data in chronological descending order, the function will return the results as expected.

/// Retrieves weather data for a given city from a Redis database.

///

/// The data is retrieved in chronological descending order.

///

/// # Arguments

///

/// * conn - A mutable Redis connection.

/// * city - The name of the city for which to retrieve data.

///

/// # Returns

///

/// A vector of weather data or a Redis error.

fn get_weather_data(conn: &mut Connection, city: &str) -> redis::RedisResult<Vec<WeatherData>> {

let records: Vec<String> = conn.lrange(city, 0, -1)?;

let mut response: Vec<WeatherData> = Vec::new();

for record in records {

let data: WeatherData = serde_json::from_str(&record).unwrap();

response.push(data);

}

Ok(response)

}

The complete code snippet

//! A simple weather data storage and retrieval system using Redis.

use redis::{Client, Commands, Connection};

use serde_derive::{Serialize, Deserialize};

use serde_json::to_string;

use chrono::{Utc, NaiveDateTime};

fn main() {

// Create a Redis connection

let client = Client::open("redis://127.0.0.1:6379/").expect("Failed to create Redis client");

let mut con = client.get_connection().expect("Failed to connect to Redis");

// Inserting data

let data1 = WeatherData {

current_date: Utc::now().naive_utc(),

temperature: "25".to_string(),

city: "New York".to_string(),

};

match save_weather_data(&mut con, &data1) {

Ok(_) => println!("Data1 saved successfully!"),

Err(e) => println!("Error saving data1: {}", e),

};

// Simulate a time gap before inserting the next data

std::thread::sleep(std::time::Duration::from_secs(2));

let data2 = WeatherData {

current_date: Utc::now().naive_utc(),

temperature: "24".to_string(),

city: "New York".to_string(),

};

match save_weather_data(&mut con, &data2) {

Ok(_) => println!("Data2 saved successfully!"),

Err(e) => println!("Error saving data2: {}", e),

}

// Retrieving data

match get_weather_data(&mut con, "New York") {

Ok(weather_data) => {

println!("Weather data for New York in chronological descending order:");

for data in weather_data {

println!("Date: {}, Temperature: {}", data.current_date, data.temperature);

}

},

Err(e) => println!("Error retrieving data for New York: {}", e),

}

}

Conclusion

In this article, we demonstrated how to utilize the LPUSH command in Redis with Rust to effectively store and retrieve data in reverse chronological order. By inserting elements at the beginning of the list, we can effortlessly maintain an ordered collection of records according to their addition time. This approach can be applied in various scenarios requiring time-based data organization.

The first video provides a step-by-step guide to building a journaling app using Rust and Upstash Redis, showcasing practical applications of the concepts discussed.

The second video features a live stream on connecting to Redis in Axum with Rust, offering insights into real-world implementations.