docs: add Rust examples to concept pages and quickstart (#34)

Add a Rust tab to every per-SDK example block across the feature pages —
ephemerals, sequence keys, secondary indexes, notifications, namespaces,
key sorting, versioning, and partition keys — so Rust sits alongside Go,
Java, Python, and Node.js everywhere they appear. Each Rust snippet
mirrors its sibling tabs using the oxia-client fluent builder API.

Also link the Rust SDK from the getting-started "Using client SDKs" list.

Signed-off-by: Matteo Merli <mmerli@apache.org>

Author: merlimat

src/content/features/ephemerals.mdx

@@ -29,7 +29,7 @@ Ephemeral records can be used to implement many system coordination tasks, such
 
 When creating/modifying a record, applications can specify the "ephemeral" option:
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust']}>
     <Tabs.Tab>
         ```go
         insertedKey, res, err := client.Put(context.Background(),
@@ -53,6 +53,11 @@ When creating/modifying a record, applications can specify the "ephemeral" optio
         const { key, version } = await client.put('my-key', 'my-value', { ephemeral: true });
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        let res = client.put("my-key", "my-value").ephemeral().await?;
+        ```
+    </Tabs.Tab>
 </Tabs>
 
 
@@ -82,7 +87,7 @@ new session.
 
 A client can optionally specify a client identifier that will be tied to the session.
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust']}>
     <Tabs.Tab>
         ```go
         client, err := oxia.NewClient("localhost:6648", oxia.WithIdentity("my-client-identity"))
@@ -107,6 +112,15 @@ A client can optionally specify a client identifier that will be tied to the ses
         });
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        let client = OxiaClient::builder()
+            .service_address("localhost:6648")
+            .identity("my-client-identity")
+            .build()
+            .await?;
+        ```
+    </Tabs.Tab>
 </Tabs>
 
 The client identity is stored as part of the version object, for ephemeral records, and will

src/content/features/namespaces.mdx

@@ -12,7 +12,7 @@ Each namespace has its own independent key-space and set of shards.
 When creating an Oxia client, it's possible to specify the namespace to be used. If not provided,
 the client will use the `default` namespace.
 
- <Tabs items={['Go', 'Java', 'Python', 'Node.js', 'CLI']}>
+ <Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust', 'CLI']}>
         <Tabs.Tab>
             ```go
             client, err := oxia.NewClient("localhost:6648", oxia.WithNamespace("my-namespace"))
@@ -37,6 +37,15 @@ the client will use the `default` namespace.
             });
             ```
         </Tabs.Tab>
+        <Tabs.Tab>
+            ```rust
+            let client = OxiaClient::builder()
+                .service_address("localhost:6648")
+                .namespace("my-namespace")
+                .build()
+                .await?;
+            ```
+        </Tabs.Tab>
         <Tabs.Tab>
             ```shell
             oxia client --namespace my-namespace put my-key my-value

src/content/features/notifications.mdx

@@ -11,7 +11,7 @@ of failures.
 
 ## Subscribing to notifications
 
- <Tabs items={['Go', 'Java', 'Python', 'Node.js', 'CLI']}>
+ <Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust', 'CLI']}>
         <Tabs.Tab>
             ```go
             notifications, err := client.GetNotifications()
@@ -47,6 +47,14 @@ of failures.
             }
             ```
         </Tabs.Tab>
+        <Tabs.Tab>
+            ```rust
+            let mut notifications = client.notifications().await?;
+            while let Some(notification) = notifications.recv().await {
+                println!("{notification}");
+            }
+            ```
+        </Tabs.Tab>
         <Tabs.Tab>
             ```shell
             oxia client notifications

src/content/features/oxia-key-sorting.mdx

@@ -34,7 +34,7 @@ For example, given the following keys, the storage order would be:
 
 Querying for the direct children of `/xyz/`:
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'CLI']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust', 'CLI']}>
     <Tabs.Tab>
         ```go
         keys, _ := client.List(context.Background(), "/xyz/", "/xyz//")
@@ -59,6 +59,12 @@ Querying for the direct children of `/xyz/`:
         // Returns: ["/xyz/A", "/xyz/B", "/xyz/C"]
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        let keys = client.list("/xyz/", "/xyz//").await?;
+        // Returns: ["/xyz/A", "/xyz/B", "/xyz/C"]
+        ```
+    </Tabs.Tab>
     <Tabs.Tab>
         ```shell
         $ oxia client list -s /xyz/ -e /xyz//

src/content/features/partition-keys.mdx

@@ -32,7 +32,7 @@ All operations that need to interact with co-located records should use the same
 The `PartitionKey` option is available on all client operations: `Put`, `Get`, `Delete`,
 `DeleteRange`, `List`, and `RangeScan`.
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'CLI']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust', 'CLI']}>
     <Tabs.Tab>
         ```go
         // Store related records on the same shard
@@ -95,6 +95,27 @@ The `PartitionKey` option is available on all client operations: `Put`, `Get`, `
         });
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        // Store related records on the same shard
+        client.put("/users/123/profile", "profile-data")
+            .partition_key("/users/123")
+            .await?;
+        client.put("/users/123/settings", "settings-data")
+            .partition_key("/users/123")
+            .await?;
+
+        // List all records for user 123 (works because they share a partition key)
+        let keys = client.list("/users/123/", "/users/123//")
+            .partition_key("/users/123")
+            .await?;
+
+        // Delete all records for user 123
+        client.delete_range("/users/123/", "/users/123//")
+            .partition_key("/users/123")
+            .await?;
+        ```
+    </Tabs.Tab>
     <Tabs.Tab>
         ```shell
         $ oxia client put /users/123/profile -c --partition-key /users/123 <<< "profile-data"

src/content/features/secondary-indexes.mdx

@@ -30,7 +30,7 @@ matching records.
 
 ### Writing records with secondary indexes
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'CLI']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust', 'CLI']}>
     <Tabs.Tab>
         ```go
         // Index a user record by email
@@ -63,6 +63,15 @@ matching records.
         );
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        // Index a user record by email
+        client
+            .put("/users/123", r#"{"name":"Alice","email":"alice@example.com"}"#)
+            .secondary_index("by-email", "alice@example.com")
+            .await?;
+        ```
+    </Tabs.Tab>
     <Tabs.Tab>
         ```shell
         $ oxia client put /users/123 -d '{"name":"Alice","email":"alice@example.com"}'
@@ -74,7 +83,7 @@ matching records.
 
 Use the `UseIndex` option on `Get`, `List`, or `RangeScan` to query using secondary keys.
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'CLI']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust', 'CLI']}>
     <Tabs.Tab>
         ```go
         // Lookup by secondary index
@@ -141,6 +150,20 @@ Use the `UseIndex` option on `Get`, `List`, or `RangeScan` to query using second
         }
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        // Lookup by secondary index
+        let record = client.get("alice@example.com").use_index("by-email").await?;
+
+        // List all keys in a secondary index range
+        let keys = client.list("a", "b").use_index("by-email").await?;
+
+        // Range scan using secondary index
+        for record in client.range_scan("a", "b").use_index("by-email").await? {
+            println!("primary key: {}, value: {:?}", record.key, record.value);
+        }
+        ```
+    </Tabs.Tab>
     <Tabs.Tab>
         ```shell
         # Get by secondary index

src/content/features/sequence-keys.mdx

@@ -30,7 +30,7 @@ are routed to the same shard.
 
 ## Using sequence keys
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'CLI']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust', 'CLI']}>
     <Tabs.Tab>
         ```go
         // Write a record with a server-assigned sequence key.
@@ -72,6 +72,18 @@ are routed to the same shard.
         console.log('Inserted at:', key);
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        // Write a record with a server-assigned sequence key.
+        // The final key will be something like "/events/00000000000000000001"
+        let res = client
+            .put("/events/", "event-data")
+            .partition_key("/events/")
+            .sequence_key_deltas([1])
+            .await?;
+        println!("Inserted at: {}", res.key);
+        ```
+    </Tabs.Tab>
     <Tabs.Tab>
         ```shell
         $ oxia client put /events/ -c --partition-key /events/ --sequence-keys-deltas 1 <<< "event-data"
@@ -99,7 +111,7 @@ insertedKey, _, err := client.Put(context.Background(),
 Clients can subscribe to receive updates whenever new sequence keys are generated for a given
 prefix. This is useful for consumers that need to react to new entries.
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'CLI']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust', 'CLI']}>
     <Tabs.Tab>
         ```go
         ch, err := client.GetSequenceUpdates(context.Background(),
@@ -140,6 +152,14 @@ prefix. This is useful for consumers that need to react to new entries.
         }
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        let mut updates = client.sequence_updates("/events/", "/events/").await?;
+        while let Some(key) = updates.recv().await {
+            println!("New sequence key: {}", key);
+        }
+        ```
+    </Tabs.Tab>
     <Tabs.Tab>
         ```shell
         $ oxia client sequence-updates /events/ --partition-key /events/

src/content/features/versioning.mdx

@@ -15,7 +15,7 @@ The versioning is usually used for **Optimistic Concurrency Control (OCC)**. Ins
 
 ## Using Versioning
 
-<Tabs items={['Go', 'Java', 'Python', 'Node.js']}>
+<Tabs items={['Go', 'Java', 'Python', 'Node.js', 'Rust']}>
     <Tabs.Tab>
         ```go
         // read version
@@ -73,4 +73,16 @@ The versioning is usually used for **Optimistic Concurrency Control (OCC)**. Ins
         await client.put('a', 'a2', { expectedVersionId: version.versionId });
         ```
     </Tabs.Tab>
+    <Tabs.Tab>
+        ```rust
+        // read version
+        let record = client.get("a").await?;
+
+        // case-1: expect not exists
+        client.put("a", "a2").expected_record_not_exists().await?;
+
+        // case-2: expect by version
+        client.put("a", "a2").expected_version_id(record.version.version_id).await?;
+        ```
+    </Tabs.Tab>
 </Tabs>

src/content/getting-started.mdx

@@ -120,5 +120,6 @@ Before running anything, here are the building blocks you will encounter.
      1. [Go SDK](/docs/clients/go)
      1. [Python SDK](/docs/clients/python)
      1. [Node.js SDK](/docs/clients/node)
+     1. [Rust SDK](/docs/clients/rust)
 
 </Steps>