In the previous page, we established that stable storage is achieved through redundancy—storing data on multiple independent devices such that no single failure can cause data loss. But how do we actually implement this redundancy in practice?

The answer, for over four decades, has been RAID (Redundant Array of Independent Disks). RAID is not a single technology but a family of techniques for combining multiple physical storage devices into a logical unit that provides improved reliability, performance, or both.

RAID is so fundamental to database systems that you will encounter it in virtually every production deployment. Understanding RAID levels, their tradeoffs, and their failure characteristics is essential knowledge for any database professional.

RAID was introduced in 1988 by Patterson, Gibson, and Katz at UC Berkeley. Their seminal paper, "A Case for Redundant Arrays of Inexpensive Disks (RAID)," proposed using multiple low-cost drives to match or exceed the performance and reliability of expensive mainframe storage.

The Core RAID Concepts:

1. Striping

Data is divided into chunks (called stripes or strips) and distributed across multiple drives. This allows parallel access—multiple drives can satisfy a single request simultaneously, increasing throughput.

2. Mirroring

Data is duplicated across multiple drives. If one drive fails, the mirror contains an identical copy. This provides fault tolerance at the cost of storage capacity.

3. Parity

Redundant information is computed and stored that allows reconstruction of lost data. Parity provides fault tolerance with less storage overhead than full mirroring.

RAID Implementations:

RAID can be implemented at different levels of the storage stack:

Hardware RAID

A dedicated RAID controller with its own processor handles all RAID operations. The controller presents a single logical drive to the operating system. High-end controllers include battery-backed cache for write performance and durability.

Advantages: Best performance, OS-independent, transparent to software Disadvantages: Expensive, vendor lock-in, failed controller requires compatible replacement

Software RAID

The operating system or storage driver implements RAID logic using the host CPU. Linux mdadm, Windows Storage Spaces, and ZFS all implement software RAID.

Advantages: No special hardware, portable across systems, CPU overhead trivial for modern processors Disadvantages: Uses host CPU, slightly lower performance, OS-dependent

Database-Level RAID

Some database systems implement their own redundancy. Oracle ASM (Automatic Storage Management) provides mirroring and striping independent of the OS or hardware RAID.

RAID 0, despite the name, provides no redundancy whatsoever. It uses striping to distribute data across multiple drives for improved performance, but a single drive failure causes complete data loss.

How RAID 0 Works:

Data is divided into stripes (typically 64KB to 256KB) and written round-robin across all drives in the array:

Drive 0       Drive 1       Drive 2       Drive 3
┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐
│ Stripe 0│   │ Stripe 1│   │ Stripe 2│   │ Stripe 3│
├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤
│ Stripe 4│   │ Stripe 5│   │ Stripe 6│   │ Stripe 7│
├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤
│ Stripe 8│   │ Stripe 9│   │ Stripe10│   │ Stripe11│
└─────────┘   └─────────┘   └─────────┘   └─────────┘

Performance Characteristics:

• Read Throughput: Excellent. Large sequential reads can utilize all drives in parallel.
• Write Throughput: Excellent. Writes distribute across all drives simultaneously.
• Random IOPS: Good. Requests spread across drives, reducing per-drive load.
• Latency: Same as single drive (no extra overhead).

RAID 0 Properties:

Legitimate Uses for RAID 0:

Despite its dangers, RAID 0 has valid applications:

• Temporary/scratch space where data can be regenerated if lost
• Read-only data that can be restored from source
• Low-tier storage in tiered architectures where the data also exists elsewhere
• Testing environments where data loss is acceptable

For database systems, RAID 0 alone is almost never appropriate. However, it forms a building block for other RAID levels (like RAID 10).

RAID 1 is the simplest form of redundancy: every write is duplicated to two (or more) drives. Either drive can satisfy any read, and if one drive fails, the other contains a complete copy of all data.

How RAID 1 Works:

                    Write Request
                         │
                    ┌────┴────┐
                    │         │
                    ▼         ▼
               ┌─────────┐ ┌─────────┐
               │ Drive A │ │ Drive B │
               │ (Copy 1)│ │ (Copy 2)│
               │         │ │         │
               │ Block 0 │ │ Block 0 │
               │ Block 1 │ │ Block 1 │
               │ Block 2 │ │ Block 2 │
               │   ...   │ │   ...   │
               └─────────┘ └─────────┘
                    │         │
                    └────┬────┘
                         │
                   Read Request
               (Either drive can respond)

Performance Characteristics:

• Read Throughput: Can be 2× a single drive (reads from either copy).
• Read IOPS: Can be 2× (load balancing across mirrors).
• Write Throughput: Same as single drive (both copies must be written).
• Write IOPS: Same as single drive (limited by slowest mirror).
• Latency: Reads: same as single drive. Writes: limited by slowest drive.

RAID 5 strikes a balance between the performance of RAID 0 and the protection of RAID 1. It uses striping with distributed parity—redundant information computed from the data that allows reconstruction of any single failed drive.

How RAID 5 Works:

Data is striped across drives like RAID 0, but one stripe in each row is a parity stripe computed from the other stripes using XOR:

Drive 0       Drive 1       Drive 2       Drive 3
┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐
│  D0     │   │  D1     │   │  D2     │   │  P0     │  Row 0
├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤
│  D3     │   │  D4     │   │  P1     │   │  D5     │  Row 1
├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤
│  D6     │   │  P2     │   │  D7     │   │  D8     │  Row 2
├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤
│  P3     │   │  D9     │   │  D10    │   │  D11    │  Row 3
└─────────┘   └─────────┘   └─────────┘   └─────────┘

P0 = D0 XOR D1 XOR D2
P1 = D3 XOR D4 XOR D5
... and so on

If Drive 1 fails:
D1 = D0 XOR D2 XOR P0  (can be reconstructed!)

The parity is distributed across all drives rather than concentrated on a single drive. This prevents the parity drive from becoming a bottleneck.

RAID 5 Write Operations in Detail:

Small Write (Read-Modify-Write):

1. Read old data block
2. Read old parity block  
3. Compute: new_parity = old_parity XOR old_data XOR new_data
4. Write new data block
5. Write new parity block

Total: 2 reads + 2 writes = 4 I/O operations per logical write

Full Stripe Write (Optimal):

If writing all data blocks in a stripe simultaneously:
1. Compute parity from all new data blocks
2. Write all data blocks + parity block in parallel

Total: n writes (no reads required)

The full stripe write path is why sequential write workloads perform well on RAID 5, while random writes suffer significantly.

Capacity Efficiency vs. Drive Count:

RAID 6 extends RAID 5 by adding a second parity block to each stripe, computed using a different algorithm. This allows the array to survive two simultaneous drive failures.

Why RAID 6 Matters:

RAID 5's single-drive fault tolerance has become increasingly risky as drives grow larger:

1. Larger drives take longer to rebuild — A 10TB drive might take 24-48 hours to rebuild, during which the array is vulnerable.

2. Unrecoverable Read Errors (URE) — Modern drives have URE rates around 10^14 (one per 12.5TB read). During a rebuild of a large array, hitting an URE on another drive is increasingly likely, causing data loss.

3. Rebuild stress can trigger failures — The intensive I/O during rebuild operation can trigger latent failures in other aging drives.

How RAID 6 Works:

RAID 6 uses two independent parity calculations, typically denoted P and Q:

Drive 0       Drive 1       Drive 2       Drive 3       Drive 4
┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐
│  D0     │   │  D1     │   │  D2     │   │  P0     │   │  Q0     │
├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤
│  D3     │   │  D4     │   │  P1     │   │  Q1     │   │  D5     │
├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤
│  D6     │   │  P2     │   │  Q2     │   │  D7     │   │  D8     │
├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤
│  P3     │   │  Q3     │   │  D9     │   │  D10    │   │  D11    │
└─────────┘   └─────────┘   └─────────┘   └─────────┘   └─────────┘

P = Simple XOR parity
Q = Reed-Solomon or other algebraic code

With both P and Q, any two drives can be reconstructed

RAID 6 Write Penalty:

RAID 6's write penalty is worse than RAID 5 because two parity blocks must be updated:

Small Write:
1. Read old data block
2. Read old P block
3. Read old Q block
4. Compute new P and new Q
5. Write new data block
6. Write new P block
7. Write new Q block

Total: 3 reads + 3 writes = 6 I/O operations per logical write

RAID 10 (also written as RAID 1+0) combines the performance benefits of RAID 0 striping with the reliability of RAID 1 mirroring. It's often considered the premium choice for database storage that requires both high performance and high reliability.

How RAID 10 Works:

Data is first mirrored (RAID 1), then the mirrored pairs are striped (RAID 0):

                       RAID 0 (Striping)
    ┌───────────────────────┼───────────────────────┐
    │                       │                       │
    ▼                       ▼                       ▼
┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐
│   Mirror Pair 0 │   │   Mirror Pair 1 │   │   Mirror Pair 2 │
│                 │   │                 │   │                 │
│ ┌─────┐ ┌─────┐│   │ ┌─────┐ ┌─────┐│   │ ┌─────┐ ┌─────┐│
│ │  A  │ │  A' ││   │ │  B  │ │  B' ││   │ │  C  │ │  C' ││
│ └─────┘ └─────┘│   │ └─────┘ └─────┘│   │ └─────┘ └─────┘│
│                 │   │                 │   │                 │
│  Drive 0 Drive 1│   │  Drive 2 Drive 3│   │  Drive 4 Drive 5│
└─────────────────┘   └─────────────────┘   └─────────────────┘
        RAID 1                RAID 1                RAID 1

Stripe 0: Written to Mirror Pair 0 (drives 0 and 1)
Stripe 1: Written to Mirror Pair 1 (drives 2 and 3)
Stripe 2: Written to Mirror Pair 2 (drives 4 and 5)
... continues striping across mirror pairs

Performance Characteristics:

• Read Throughput: Excellent. All drives can contribute, and each mirror pair can serve different reads.
• Write Throughput: Very good. Writes stripe across mirror pairs; each mirror write is parallel.
• Random IOPS: Excellent. No write penalty, reads spread across all drives.
• Latency: Low. No parity calculation overhead.

RAID 10 vs. RAID 01:

RAID 10 (mirrors of stripes) is not the same as RAID 01 (stripes of mirrors):

• RAID 10: First mirror pairs, then stripe. A drive failure degrades only its mirror pair.
• RAID 01: First stripe, then mirror the stripes. A drive failure degrades an entire stripe set.

RAID 10 is almost always preferred because it has better fault tolerance characteristics and rebuilds affect only the failed drive's mirror pair.

Choosing the right RAID level for database storage requires understanding your workload characteristics. Different database components have different I/O patterns:

Transaction Logs (WAL/Redo)

• Write-intensive, small sequential writes
• Highest durability requirements
• Performance critical for commit latency
• Recommendation: RAID 1 or RAID 10

Data Files (Tables, Indexes)

• Mix of reads and writes
• Larger I/O sizes
• Can tolerate slightly higher latency
• Recommendation: RAID 10 (premium) or RAID 6 (economy)

Temporary/Working Space

• High throughput, low durability
• Can be recreated if lost
• Recommendation: RAID 0 or RAID 10

Decision Matrix:

RAID technology transforms unreliable individual drives into reliable storage systems. Let's consolidate the key concepts:

What's Next:

RAID protects against drive failures within a single system, but what about failures that affect the entire system—power surges, controller failures, or physical damage? The next page explores mirroring at the system level, including synchronous replication and hot standby configurations.