> ## Documentation Index
> Fetch the complete documentation index at: https://bunny.net/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Rust

> Get started with Bunny Database and Rust using the libSQL crate

In this Rust quickstart you will learn how to:

* Retrieve database credentials
* Install the libSQL crate
* Connect to a remote Bunny Database
* Execute a query using SQL

## Quickstart

**1. Retrieve database credentials**

You will need an existing database to continue. If you don't have one, [create one](/docs/database/quickstart).

Navigate to **Dashboard > Edge Platform > Database > \[Select Database] > Access** to find your database URL and generate an access token.

> [!NOTE]
>
> You should store these as environment variables to keep them secure.

**2. Install libsql**

Install the libSQL crate:

```bash theme={null}
cargo add libsql
```

**3. Initialize a new client**

Create a database connection with your database URL and auth token:

```rust theme={null}
use libsql::Builder;

let url = std::env::var("BUNNY_DATABASE_URL").expect("BUNNY_DATABASE_URL must be set");
let token = std::env::var("BUNNY_DATABASE_AUTH_TOKEN").expect("BUNNY_DATABASE_AUTH_TOKEN must be set");

let db = Builder::new_remote(url, token)
    .build()
    .await?;
let conn = db.connect()?;
```

**4. Execute a query using SQL**

You can execute a SQL query against your database using `query()` for reads or `execute()` for writes:

```rust theme={null}
let mut rows = conn.query("SELECT * FROM users", ()).await?;

while let Some(row) = rows.next().await? {
    let id: i64 = row.get(0)?;
    let name: String = row.get(1)?;
    println!("User: {} - {}", id, name);
}
```

If you need to use placeholders for values, you can do that:

```rust Positional theme={null}
conn.query("SELECT * FROM users WHERE id = ?1", libsql::params![1]).await?;
```

```rust Named theme={null}
conn.query("SELECT * FROM users WHERE id = :id", libsql::named_params! { ":id": 1 }).await?;
```

## Placeholders

libSQL supports the use of positional and named placeholders within SQL statements:

```rust Positional theme={null}
conn.query("SELECT * FROM users WHERE id = ?1", libsql::params![1]).await?;
```

```rust Named theme={null}
conn.query("SELECT * FROM users WHERE id = :id", libsql::named_params! { ":id": 1 }).await?;
```

> [!NOTE]
>
> libSQL supports the same named placeholder characters as SQLite — `:`, `@` and
> `$`.

## Executing Writes

Use `execute()` for INSERT, UPDATE, and DELETE statements:

```rust theme={null}
conn.execute("INSERT INTO users (name) VALUES (?1)", libsql::params!["Kit"]).await?;
```

You can also use named parameters:

```rust theme={null}
conn.execute(
    "INSERT INTO users (name) VALUES (:name)",
    libsql::named_params! { ":name": "Kit" }
).await?;
```

## Transactions

You can use transactions to execute multiple statements atomically:

```rust theme={null}
let tx = conn.transaction().await?;

tx.execute("INSERT INTO users (name) VALUES (?1)", libsql::params!["Kit"]).await?;
tx.execute("INSERT INTO users (name) VALUES (?1)", libsql::params!["Sam"]).await?;

tx.commit().await?;
```

To roll back a transaction:

```rust theme={null}
let tx = conn.transaction().await?;

tx.execute("INSERT INTO users (name) VALUES (?1)", libsql::params!["Kit"]).await?;

// Roll back the transaction
tx.rollback().await?;
```

## Batch Execution

You can execute multiple SQL statements in a single call:

```rust theme={null}
conn.execute_batch(
    "BEGIN;
     INSERT INTO users (name) VALUES ('Kit');
     INSERT INTO users (name) VALUES ('Sam');
     COMMIT;"
).await?;
```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.