Getting Started with Couchbase and Rust

Couchbase is a modern NoSQL database known for its high performance, scalability, and flexibility. If you're developing applications in Rust and want to leverage Couchbase for your database needs, this guide will walk you through the setup and usage of Couchbase with Rust.

Prerequisites Couchbase and Rust

Before we begin, ensure you have the following:

Couchbase Server:

Download and install Couchbase Server from Couchbase Downloads.

Start Couchbase Server and set up an administrator username and password.

Rust Development Environment:

Install Rust using rustup.

Verify the installation by running:

rustc --version
cargo --version

Couchbase Rust SDK:

Install the Couchbase Rust SDK by adding it to your project's Cargo.toml file.

Step 1: Setting Up a Couchbase Cluster

Access Couchbase Web Console:

Open http://localhost:8091 in your web browser.

Log in using your administrator credentials.

Create a Bucket:

Navigate to the "Buckets" section.

Create a new bucket named example_bucket.

Enable the Query Service:

Ensure the Query service is enabled for executing N1QL queries.

Step 2: Setting Up a Rust Project

Create a New Rust Project:

cargo new couchbase_rust_example
cd couchbase_rust_example

Add Dependencies:
Update your Cargo.toml file with the following dependencies:

[dependencies]
couchbase = "1.0"
tokio = { version = "1", features = ["full"] }

Step 3: Connecting to Couchbase

Create a file named main.rs with the following code:

use couchbase::{Cluster, ClusterOptions};
use tokio;

#[tokio::main]
async fn main() -> Result<(), couchbase::CouchbaseError> {
    // Define connection string and credentials
    let connection_string = "couchbase://127.0.0.1";
    let username = "Administrator";
    let password = "password";

    // Connect to the Couchbase cluster
    let options = ClusterOptions::new(username, password);
    let cluster = Cluster::connect(connection_string, options).await?;

    println!("Connected to Couchbase!");

    Ok(())
}

Run the application:

cargo run

If successful, it should print "Connected to Couchbase!".

Step 4: Basic CRUD Operations Couchbase and Rust

Insert a Document

Add the following code to main.rs:

    // Open a bucket and collection
    let bucket = cluster.bucket("example_bucket");
    let collection = bucket.default_collection();

    // Create a document
    let doc_id = "user:123";
    let doc_content = serde_json::json!({
        "name": "John Doe",
        "email": "johndoe@example.com",
        "age": 29
    });

    // Insert the document
    collection.upsert(doc_id, doc_content, None).await?;
    println!("Document inserted!");

Retrieve a Document

    // Get the document
    let result = collection.get(doc_id, None).await?;
    let content: serde_json::Value = result.content()?;
    println!("Retrieved document: {}", content);

Update a Document

    // Update the document
    let updated_content = serde_json::json!({
        "name": "John Doe",
        "email": "john.doe@newdomain.com",
        "age": 30
    });
    collection.upsert(doc_id, updated_content, None).await?;
    println!("Document updated!");

Delete a Document

    // Delete the document
    collection.remove(doc_id, None).await?;
    println!("Document deleted!");

Step 5: Querying with N1QL

To enable N1QL queries, add the following code:

    // Define a N1QL query
    let query = "SELECT name, email FROM `example_bucket` WHERE age > $1";
    let options = couchbase::QueryOptions::default().named_parameters(serde_json::json!([25]));

    // Execute the query
    let result = cluster.query(query, options).await?;
    for row in result.rows::<serde_json::Value>() {
        println!("Query result: {}", row?);
    }

Step 6: Error Handling and Best Practices

• Error Handling: Use Result and ? operators to handle errors gracefully.
• Connection Pooling: Reuse Cluster and Bucket instances to optimize performance.
• Configuration: Store credentials and configuration in environment variables or configuration files.

You have successfully set up Couchbase with Rust and performed basic CRUD operations and queries. Explore more features of Couchbase, such as full-text search and analytics, to enhance your application further.  Hope this is helpful, and I apologize if there are any inaccuracies in the information provided.  Hope this is helpful, and I apologize if there are any inaccuracies in the information provided.