Struct DatabaseHandler 

pub struct DatabaseHandler { /* private fields */ }

Handler for Pro database operations

Manages database lifecycle, configuration, backup/restore, import/export, and monitoring for Redis Cloud Pro subscriptions.

Implementations

impl DatabaseHandler

pub fn new(client: CloudClient) -> Self

Create a new handler

pub async fn get_subscription_databases( &self, subscription_id: i32, offset: Option<i32>, limit: Option<i32>, ) -> Result<AccountSubscriptionDatabases>

Get all databases in a Pro subscription

Gets a list of all databases in the specified Pro subscription.

GET /subscriptions/{subscriptionId}/databases

Arguments

• subscription_id - The subscription ID
• offset - Optional offset for pagination
• limit - Optional limit for pagination

Example

use redis_cloud::CloudClient;

let client = CloudClient::builder()
    .api_key("your-api-key")
    .api_secret("your-api-secret")
    .build()?;

// Get all databases in subscription 123
let databases = client.databases().get_subscription_databases(123, None, None).await?;

// With pagination
let page = client.databases().get_subscription_databases(123, Some(0), Some(10)).await?;

pub async fn create_database( &self, subscription_id: i32, request: &DatabaseCreateRequest, ) -> Result<TaskStateUpdate>

Create Pro database in existing subscription Creates a new database in an existing Pro subscription.

POST /subscriptions/{subscriptionId}/databases

pub async fn delete_database_by_id( &self, subscription_id: i32, database_id: i32, ) -> Result<TaskStateUpdate>

Delete Pro database Deletes a database from a Pro subscription.

DELETE /subscriptions/{subscriptionId}/databases/{databaseId}

pub async fn get_subscription_database_by_id( &self, subscription_id: i32, database_id: i32, ) -> Result<Database>

Get a single Pro database

Gets details and settings of a single database in a Pro subscription.

GET /subscriptions/{subscriptionId}/databases/{databaseId}

Example

use redis_cloud::CloudClient;

let client = CloudClient::builder()
    .api_key("your-api-key")
    .api_secret("your-api-secret")
    .build()?;

let database = client.databases().get_subscription_database_by_id(123, 456).await?;

println!("Database: {} (status: {:?})",
    database.name.unwrap_or_default(),
    database.status);

pub async fn update_database( &self, subscription_id: i32, database_id: i32, request: &DatabaseUpdateRequest, ) -> Result<TaskStateUpdate>

Update Pro database Updates an existing Pro database.

PUT /subscriptions/{subscriptionId}/databases/{databaseId}

pub async fn get_database_backup_status( &self, subscription_id: i32, database_id: i32, region_name: Option<String>, ) -> Result<TaskStateUpdate>

Get Pro database backup status Gets information on the latest backup attempt for this Pro database.

GET /subscriptions/{subscriptionId}/databases/{databaseId}/backup

pub async fn backup_database( &self, subscription_id: i32, database_id: i32, request: &DatabaseBackupRequest, ) -> Result<TaskStateUpdate>

Back up Pro database Manually back up the specified Pro database to a backup path. By default, backups will be stored in the ‘remoteBackup’ location for this database.

POST /subscriptions/{subscriptionId}/databases/{databaseId}/backup

pub async fn get_subscription_database_certificate( &self, subscription_id: i32, database_id: i32, ) -> Result<DatabaseCertificate>

Get Pro database TLS certificate Gets the X.509 PEM (base64) encoded server certificate for TLS connection to the database. Requires ‘enableTLS’ to be ‘true’ for the database.

GET /subscriptions/{subscriptionId}/databases/{databaseId}/certificate

pub async fn flush_crdb( &self, subscription_id: i32, database_id: i32, request: &CrdbFlushRequest, ) -> Result<TaskStateUpdate>

Flush Pro database Deletes all data from the specified Pro database.

PUT /subscriptions/{subscriptionId}/databases/{databaseId}/flush

pub async fn get_database_import_status( &self, subscription_id: i32, database_id: i32, ) -> Result<TaskStateUpdate>

Get Pro database import status Gets information on the latest import attempt for this Pro database.

GET /subscriptions/{subscriptionId}/databases/{databaseId}/import

pub async fn import_database( &self, subscription_id: i32, database_id: i32, request: &DatabaseImportRequest, ) -> Result<TaskStateUpdate>

Import data to a Pro database Imports data from an RDB file or from a different Redis database into this Pro database. WARNING: Importing data into a database removes all existing data from the database.

POST /subscriptions/{subscriptionId}/databases/{databaseId}/import

pub async fn update_crdb_local_properties( &self, subscription_id: i32, database_id: i32, request: &CrdbUpdatePropertiesRequest, ) -> Result<TaskStateUpdate>

Update Active-Active database (Active-Active databases only) Updates database properties for an Active-Active database.

PUT /subscriptions/{subscriptionId}/databases/{databaseId}/regions

pub async fn get_slow_log( &self, subscription_id: i32, database_id: i32, region_name: Option<String>, ) -> Result<DatabaseSlowLogEntries>

Get database slowlog Gets the slowlog for a specific database.

GET /subscriptions/{subscriptionId}/databases/{databaseId}/slow-log

pub async fn get_tags( &self, subscription_id: i32, database_id: i32, ) -> Result<CloudTags>

Get database tags Gets a list of all database tags.

GET /subscriptions/{subscriptionId}/databases/{databaseId}/tags

pub async fn create_tag( &self, subscription_id: i32, database_id: i32, request: &DatabaseTagCreateRequest, ) -> Result<CloudTag>

Add a database tag Adds a single database tag to a database.

POST /subscriptions/{subscriptionId}/databases/{databaseId}/tags

pub async fn update_tags( &self, subscription_id: i32, database_id: i32, request: &DatabaseTagsUpdateRequest, ) -> Result<CloudTags>

Overwrite database tags Overwrites all tags on the database.

PUT /subscriptions/{subscriptionId}/databases/{databaseId}/tags

pub async fn delete_tag( &self, subscription_id: i32, database_id: i32, tag_key: String, ) -> Result<HashMap<String, Value>>

Delete database tag Removes the specified tag from the database.

DELETE /subscriptions/{subscriptionId}/databases/{databaseId}/tags/{tagKey}

pub async fn update_tag( &self, subscription_id: i32, database_id: i32, tag_key: String, request: &DatabaseTagUpdateRequest, ) -> Result<CloudTag>

Update database tag value Updates the value of the specified database tag.

PUT /subscriptions/{subscriptionId}/databases/{databaseId}/tags/{tagKey}

pub async fn get_database_redis_version_upgrade_status( &self, subscription_id: i32, database_id: i32, ) -> Result<BdbVersionUpgradeStatus>

Get Pro database version upgrade status Gets information on the latest upgrade attempt for this Pro database.

GET /subscriptions/{subscriptionId}/databases/{databaseId}/upgrade

pub async fn upgrade_database_redis_version( &self, subscription_id: i32, database_id: i32, request: &DatabaseUpgradeRedisVersionRequest, ) -> Result<TaskStateUpdate>

Upgrade Pro database version

POST /subscriptions/{subscriptionId}/databases/{databaseId}/upgrade

pub async fn get_available_target_versions( &self, subscription_id: i32, database_id: i32, ) -> Result<Value>

Get available target Redis versions for upgrade Gets a list of Redis versions that the database can be upgraded to.

GET /subscriptions/{subscriptionId}/databases/{databaseId}/available-target-versions

pub async fn flush_database( &self, subscription_id: i32, database_id: i32, ) -> Result<TaskStateUpdate>

Flush Pro database (standard, non-Active-Active) Deletes all data from the specified Pro database.

PUT /subscriptions/{subscriptionId}/databases/{databaseId}/flush

pub fn stream_databases( &self, subscription_id: i32, ) -> impl Stream<Item = Result<Database>> + '_

Stream all databases in a Pro subscription

Returns an async stream that automatically handles pagination, yielding individual Database items. This is useful when you need to process a large number of databases without loading them all into memory at once.

Arguments

• subscription_id - The subscription ID

Example

use redis_cloud::CloudClient;
use futures::StreamExt;
use std::pin::pin;

let client = CloudClient::builder()
    .api_key("your-api-key")
    .api_secret("your-api-secret")
    .build()?;

let handler = client.databases();
let mut stream = pin!(handler.stream_databases(123));
while let Some(result) = stream.next().await {
    let database = result?;
    println!("Database: {} (ID: {})", database.name.unwrap_or_default(), database.database_id);
}

pub fn stream_databases_with_page_size( &self, subscription_id: i32, page_size: i32, ) -> impl Stream<Item = Result<Database>> + '_

Stream all databases with custom page size

Like stream_databases, but allows specifying the page size for API requests.

Arguments

• subscription_id - The subscription ID
• page_size - Number of databases to fetch per API request

pub async fn get_all_databases( &self, subscription_id: i32, ) -> Result<Vec<Database>>

Get all databases in a subscription (collected)

Fetches all databases by automatically handling pagination and returns them as a single vector. Use stream_databases if you prefer to process databases one at a time.

Arguments

• subscription_id - The subscription ID

Example

use redis_cloud::CloudClient;

let client = CloudClient::builder()
    .api_key("your-api-key")
    .api_secret("your-api-secret")
    .build()?;

let all_databases = client.databases().get_all_databases(123).await?;
println!("Total databases: {}", all_databases.len());