...

instructions/hset_redis_functions.md

@@ -0,0 +1,307 @@
+
+# 🔑 Redis `HSET` and Related Hash Commands
+
+## 1. `HSET`
+
+* **Purpose**: Set the value of one or more fields in a hash.
+* **Syntax**:
+
+  ```bash
+  HSET key field value [field value ...]
+  ```
+* **Return**:
+
+  * Integer: number of fields that were newly added.
+* **RESP Protocol**:
+
+  ```
+  *4
+  $4
+  HSET
+  $3
+  key
+  $5
+  field
+  $5
+  value
+  ```
+
+  (If multiple field-value pairs: `*6`, `*8`, etc.)
+
+---
+
+## 2. `HSETNX`
+
+* **Purpose**: Set the value of a hash field only if it does **not** exist.
+* **Syntax**:
+
+  ```bash
+  HSETNX key field value
+  ```
+* **Return**:
+
+  * `1` if field was set.
+  * `0` if field already exists.
+* **RESP Protocol**:
+
+  ```
+  *4
+  $6
+  HSETNX
+  $3
+  key
+  $5
+  field
+  $5
+  value
+  ```
+
+---
+
+## 3. `HGET`
+
+* **Purpose**: Get the value of a hash field.
+* **Syntax**:
+
+  ```bash
+  HGET key field
+  ```
+* **Return**:
+
+  * Bulk string (value) or `nil` if field does not exist.
+* **RESP Protocol**:
+
+  ```
+  *3
+  $4
+  HGET
+  $3
+  key
+  $5
+  field
+  ```
+
+---
+
+## 4. `HGETALL`
+
+* **Purpose**: Get all fields and values in a hash.
+* **Syntax**:
+
+  ```bash
+  HGETALL key
+  ```
+* **Return**:
+
+  * Array of `[field1, value1, field2, value2, ...]`.
+* **RESP Protocol**:
+
+  ```
+  *2
+  $7
+  HGETALL
+  $3
+  key
+  ```
+
+---
+
+## 5. `HMSET` (⚠️ Deprecated, use `HSET`)
+
+* **Purpose**: Set multiple field-value pairs.
+* **Syntax**:
+
+  ```bash
+  HMSET key field value [field value ...]
+  ```
+* **Return**:
+
+  * Always `OK`.
+* **RESP Protocol**:
+
+  ```
+  *6
+  $5
+  HMSET
+  $3
+  key
+  $5
+  field
+  $5
+  value
+  $5
+  field2
+  $5
+  value2
+  ```
+
+---
+
+## 6. `HMGET`
+
+* **Purpose**: Get values of multiple fields.
+* **Syntax**:
+
+  ```bash
+  HMGET key field [field ...]
+  ```
+* **Return**:
+
+  * Array of values (bulk strings or nils).
+* **RESP Protocol**:
+
+  ```
+  *4
+  $5
+  HMGET
+  $3
+  key
+  $5
+  field1
+  $5
+  field2
+  ```
+
+---
+
+## 7. `HDEL`
+
+* **Purpose**: Delete one or more fields from a hash.
+* **Syntax**:
+
+  ```bash
+  HDEL key field [field ...]
+  ```
+* **Return**:
+
+  * Integer: number of fields removed.
+* **RESP Protocol**:
+
+  ```
+  *3
+  $4
+  HDEL
+  $3
+  key
+  $5
+  field
+  ```
+
+---
+
+## 8. `HEXISTS`
+
+* **Purpose**: Check if a field exists.
+* **Syntax**:
+
+  ```bash
+  HEXISTS key field
+  ```
+* **Return**:
+
+  * `1` if exists, `0` if not.
+* **RESP Protocol**:
+
+  ```
+  *3
+  $7
+  HEXISTS
+  $3
+  key
+  $5
+  field
+  ```
+
+---
+
+## 9. `HKEYS`
+
+* **Purpose**: Get all field names in a hash.
+* **Syntax**:
+
+  ```bash
+  HKEYS key
+  ```
+* **Return**:
+
+  * Array of field names.
+* **RESP Protocol**:
+
+  ```
+  *2
+  $5
+  HKEYS
+  $3
+  key
+  ```
+
+---
+
+## 10. `HVALS`
+
+* **Purpose**: Get all values in a hash.
+* **Syntax**:
+
+  ```bash
+  HVALS key
+  ```
+* **Return**:
+
+  * Array of values.
+* **RESP Protocol**:
+
+  ```
+  *2
+  $5
+  HVALS
+  $3
+  key
+  ```
+
+---
+
+## 11. `HLEN`
+
+* **Purpose**: Get number of fields in a hash.
+* **Syntax**:
+
+  ```bash
+  HLEN key
+  ```
+* **Return**:
+
+  * Integer: number of fields.
+* **RESP Protocol**:
+
+  ```
+  *2
+  $4
+  HLEN
+  $3
+  key
+  ```
+
+
+
+## 12. `HSCAN`
+
+* **Purpose**: Iterate fields/values of a hash (cursor-based scan).
+* **Syntax**:
+
+  ```bash
+  HSCAN key cursor [MATCH pattern] [COUNT count]
+  ```
+* **Return**:
+
+  * Array: `[new-cursor, [field1, value1, ...]]`
+* **RESP Protocol**:
+
+  ```
+  *3
+  $5
+  HSCAN
+  $3
+  key
+  $1
+  0
+  ```

instructions/redb.md

@@ -0,0 +1,80 @@
+========================
+CODE SNIPPETS
+========================
+TITLE: 1PC+C Commit Strategy Vulnerability Example
+DESCRIPTION: Illustrates a scenario where a partially committed transaction might appear complete due to the non-cryptographic checksum (XXH3) used in the 1PC+C commit strategy. This requires controlling page flush order, introducing a crash during fsync, and ensuring valid checksums for partially written data.
+
+SOURCE: https://github.com/cberner/redb/blob/master/docs/design.md#_snippet_9
+
+LANGUAGE: rust
+CODE:
+```
+table.insert(malicious_key, malicious_value);
+table.insert(good_key, good_value);
+txn.commit();
+```
+
+LANGUAGE: rust
+CODE:
+```
+table.insert(malicious_key, malicious_value);
+txn.commit();
+```
+
+----------------------------------------
+
+TITLE: Basic Key-Value Operations in redb
+DESCRIPTION: Demonstrates the fundamental usage of redb for creating a database, opening a table, inserting a key-value pair, and retrieving the value within separate read and write transactions.
+
+SOURCE: https://github.com/cberner/redb/blob/master/README.md#_snippet_0
+
+LANGUAGE: rust
+CODE:
+```
+use redb::{Database, Error, ReadableTable, TableDefinition};
+
+const TABLE: TableDefinition<&str, u64> = TableDefinition::new("my_data");
+
+fn main() -> Result<(), Error> {
+    let db = Database::create("my_db.redb")?;
+    let write_txn = db.begin_write()?;
+    {
+        let mut table = write_txn.open_table(TABLE)?;
+        table.insert("my_key", &123)?;
+    }
+    write_txn.commit()?;
+
+    let read_txn = db.begin_read()?;
+    let table = read_txn.open_table(TABLE)?;
+    assert_eq!(table.get("my_key")?.unwrap().value(), 123);
+
+    Ok(())
+}
+```
+
+
+
+## What *redb* currently supports:
+
+* Simple operations like creating databases, inserting key-value pairs, opening and reading tables ([GitHub][1]).
+* No mention of operations such as:
+
+  * Iterating over keys with a given prefix.
+  * Range queries based on string prefixes.
+  * Specialized prefix‑filtered lookups.
+
+
+## implement range scans as follows
+
+You can implement prefix-like functionality using **range scans** combined with manual checks, similar to using a `BTreeSet` in Rust:
+
+```rust
+for key in table.range(prefix..).keys() {
+    if !key.starts_with(prefix) {
+        break;
+    }
+    // process key
+}
+```
+
+This pattern iterates keys starting at the prefix, and stops once a key no longer matches the prefix—this works because the keys are sorted ([GitHub][1]).

instructions/redis_basics.md

@@ -0,0 +1,250 @@
+Got it 👍 — let’s break this down properly.
+
+Redis has two broad classes you’re asking about:
+
+1. **Basic key-space functions** (SET, GET, DEL, EXISTS, etc.)
+2. **Iteration commands** (`SCAN`, `SSCAN`, `HSCAN`, `ZSCAN`)
+
+And for each I’ll show:
+
+* What it does
+* How it works at a high level
+* Its **RESP protocol implementation** (the actual wire format).
+
+---
+
+# 1. Basic Key-Space Commands
+
+### `SET key value`
+
+* Stores a string value at a key.
+* Overwrites if the key already exists.
+
+**Protocol (RESP2):**
+
+```
+*3
+$3
+SET
+$3
+foo
+$3
+bar
+```
+
+(client sends: array of 3 bulk strings: `["SET", "foo", "bar"]`)
+
+**Reply:**
+
+```
++OK
+```
+
+---
+
+### `GET key`
+
+* Retrieves the string value stored at the key.
+* Returns `nil` if key doesn’t exist.
+
+**Protocol:**
+
+```
+*2
+$3
+GET
+$3
+foo
+```
+
+**Reply:**
+
+```
+$3
+bar
+```
+
+(or `$-1` for nil)
+
+---
+
+### `DEL key [key ...]`
+
+* Removes one or more keys.
+* Returns number of keys actually removed.
+
+**Protocol:**
+
+```
+*2
+$3
+DEL
+$3
+foo
+```
+
+**Reply:**
+
+```
+:1
+```
+
+(integer reply = number of deleted keys)
+
+---
+
+### `EXISTS key [key ...]`
+
+* Checks if one or more keys exist.
+* Returns count of existing keys.
+
+**Protocol:**
+
+```
+*2
+$6
+EXISTS
+$3
+foo
+```
+
+**Reply:**
+
+```
+:1
+```
+
+---
+
+### `KEYS pattern`
+
+* Returns all keys matching a glob-style pattern.
+  ⚠️ Not efficient in production (O(N)), better to use `SCAN`.
+
+**Protocol:**
+
+```
+*2
+$4
+KEYS
+$1
+*
+```
+
+**Reply:**
+
+```
+*2
+$3
+foo
+$3
+bar
+```
+
+(array of bulk strings with key names)
+
+---
+
+# 2. Iteration Commands (`SCAN` family)
+
+### `SCAN cursor [MATCH pattern] [COUNT n]`
+
+* Iterates the keyspace incrementally.
+* Client keeps sending back the cursor from previous call until it returns `0`.
+
+**Protocol example:**
+
+```
+*2
+$4
+SCAN
+$1
+0
+```
+
+**Reply:**
+
+```
+*2
+$1
+0
+*2
+$3
+foo
+$3
+bar
+```
+
+Explanation:
+
+* First element = new cursor (`"0"` means iteration finished).
+* Second element = array of keys returned in this batch.
+
+---
+
+### `HSCAN key cursor [MATCH pattern] [COUNT n]`
+
+* Like `SCAN`, but iterates fields of a hash.
+
+**Protocol:**
+
+```
+*3
+$5
+HSCAN
+$3
+myh
+$1
+0
+```
+
+**Reply:**
+
+```
+*2
+$1
+0
+*4
+$5
+field
+$5
+value
+$5
+age
+$2
+42
+```
+
+(Array of alternating field/value pairs)
+
+---
+
+### `SSCAN key cursor [MATCH pattern] [COUNT n]`
+
+* Iterates members of a set.
+
+Protocol and reply structure same as SCAN.
+
+---
+
+### `ZSCAN key cursor [MATCH pattern] [COUNT n]`
+
+* Iterates members of a sorted set with scores.
+* Returns alternating `member`, `score`.
+
+---
+
+# Quick Comparison
+
+| Command  | Purpose                       | Return Type           |
+| -------- | ----------------------------- | --------------------- |
+| `SET`    | Store a string value          | Simple string `+OK`   |
+| `GET`    | Retrieve a string value       | Bulk string / nil     |
+| `DEL`    | Delete keys                   | Integer (count)       |
+| `EXISTS` | Check existence               | Integer (count)       |
+| `KEYS`   | List all matching keys (slow) | Array of bulk strings |
+| `SCAN`   | Iterate over keys (safe)      | `[cursor, array]`     |
+| `HSCAN`  | Iterate over hash fields      | `[cursor, array]`     |
+| `SSCAN`  | Iterate over set members      | `[cursor, array]`     |
+| `ZSCAN`  | Iterate over sorted set       | `[cursor, array]`     |
+