RAID levels represent different strategies for balancing the fundamental storage tradeoffs: performance, capacity efficiency, and fault tolerance. No single RAID level is universally optimal—each makes different sacrifices to optimize for specific workload characteristics.

The original Berkeley paper defined RAID levels 1-5. Over time, additional levels (RAID 6, RAID 10, and hybrid variations) emerged to address evolving storage requirements. Today, five RAID levels dominate production database deployments: RAID 0, RAID 1, RAID 5, RAID 6, and RAID 10.

This page provides an in-depth examination of each level, explaining not just what they do, but why they behave as they do—the architectural decisions and mathematical properties that determine their characteristics.

RAID 0 is technically not 'redundant' at all—the 'R' in RAID doesn't apply. It uses pure striping to distribute data across multiple drives without any redundancy information. Despite the lack of fault tolerance, RAID 0 remains relevant for specific use cases where performance matters more than durability.

Architecture:

Data is divided into stripes of configurable size (typically 64KB-256KB) and written sequentially across all drives in the array. With N drives, the first stripe unit goes to drive 0, the second to drive 1, and so on, wrapping around after drive N-1 back to drive 0.

When RAID 0 Is Appropriate:

Despite its fragility, RAID 0 has legitimate uses:

1. Temporary/Scratch Storage: Data that can be regenerated (temp tables, build artifacts, cache)
2. Performance Testing: When you need maximum storage performance for benchmarks
3. Non-Critical Read-Heavy Caching: If data is replicated elsewhere and cache loss is acceptable
4. Inner Layer of Nested RAID: RAID 50 (RAID 5+0) and RAID 60 (RAID 6+0) stripe across RAID 5/6 arrays

When RAID 0 Is Absolutely Wrong:

• Any production database data files
• Transaction logs or WAL
• Any data that cannot be regenerated
• Backups or archival storage

RAID 1 is the simplest redundant configuration: data is written identically to two (or more) drives simultaneously. If any drive fails, an identical copy remains available. Mirroring's simplicity makes it extremely reliable and efficient for read-intensive workloads.

Architecture:

Every write operation is duplicated to all drives in the mirror set. Reads can be served by any drive, allowing the controller to optimize read distribution (e.g., choosing the drive with the lowest seek time for a particular request).

RAID 1 Advantages:

1. Simplicity: No complex parity calculations; every failure is handled by switching to the surviving mirror
2. Read Performance: Controller can distribute reads across mirrors, effectively doubling read IOPS
3. Recovery Speed: Rebuilding a mirror is a simple drive copy—no parity reconstruction required
4. Degraded Performance: When a drive fails, performance remains near-normal (unlike parity RAID)
5. No Write Penalty: Although writes go to multiple drives, there's no computational overhead

RAID 1 Disadvantages:

1. Capacity Efficiency: Only 50% of raw capacity is usable (for 2-drive mirror)
2. No Write Scaling: Write performance doesn't improve with more drives
3. Cost: Doubles storage cost for equivalent usable capacity

RAID 1 for Databases:

RAID 1 is ideal for:

• Transaction logs: Critical for durability, small in size, sequential writes benefit from low latency
• Database boot volumes: Operating system and database binaries need reliability, not large capacity
• High-value small databases: When capacity cost is acceptable for simplicity and reliability

RAID 5 uses striping with distributed parity to provide fault tolerance while maintaining high capacity efficiency. Parity information is calculated across each stripe row and distributed across all drives—no single 'parity drive' creates a bottleneck.

Architecture:

For each stripe row, one stripe unit contains parity (XOR of all data stripe units in that row). The parity position rotates across drives to distribute the write load evenly. This distributed parity design was a significant improvement over RAID 3/4, which used dedicated parity drives.

The RAID 5 Write Penalty Explained:

Small writes in RAID 5 require the read-modify-write sequence shown above. Each logical write translates to 4 physical I/O operations:

1. Read old data block (the block being overwritten)
2. Read old parity block (the parity for that stripe row)
3. Write new data block
4. Write new parity block (calculated from old parity XOR old data XOR new data)

This 4x write penalty significantly impacts OLTP workloads with many small random writes. For sequential writes that span full stripes, the penalty is reduced because parity can be calculated directly from new data without reading old values.

Degraded Mode Performance:

When a RAID 5 drive fails, the array enters degraded mode:

• Reads from the failed drive: Reconstructed by XORing all other stripe units in the row
• Read latency increases: Every read from 'failed' data requires reading N-1 drives
• Write operations: Still require parity updates, now with reconstruction overhead
• Overall performance: Can drop by 50-75% in degraded mode

Rebuild Process:

Rebuilding a RAID 5 array after drive replacement:

1. For each stripe row, read all surviving stripe units
2. XOR them together to reconstruct the missing data
3. Write reconstructed data to the replacement drive
4. Time: Hours to days, depending on array size and I/O load

RAID 6 extends RAID 5 by adding a second independent parity calculation, enabling the array to survive any two simultaneous drive failures. This dual-parity approach addresses the rebuild vulnerability of RAID 5 with large drives.

Architecture:

RAID 6 uses two different parity algorithms:

• P (Row Parity): Standard XOR parity, same as RAID 5
• Q (Diagonal Parity): A second parity using Galois Field arithmetic, mathematically independent from P

Because P and Q are calculated differently, any two missing blocks can be reconstructed using the remaining data, P, and Q.

Reed-Solomon Coding:

The Q parity in RAID 6 uses Reed-Solomon error correction codes based on Galois Field mathematics. Unlike simple XOR, Reed-Solomon can distinguish which blocks are missing, enabling recovery of any two failures.

The mathematics are complex but the practical effect is straightforward: Q provides a second, independent redundancy check. Modern CPUs include special instructions (CLMUL, PCLMULQDQ) that accelerate Galois Field calculations, minimizing the performance impact.

RAID 6 vs. RAID 5 Comparison:

Why RAID 6 Is Now Standard:

With 18TB drives and larger becoming common:

1. RAID 5 rebuild for an 8×18TB array: 30+ hours
2. Annual failure rate: ~2-5% per drive
3. Probability of second failure during 30-hour window: Unacceptably high
4. RAID 6 provides a safety margin that RAID 5 can no longer guarantee

RAID 10 (also written RAID 1+0) combines mirroring and striping to deliver both high performance and fault tolerance without the write penalty of parity-based RAID. Data is first mirrored (RAID 1), then the mirror pairs are striped (RAID 0).

Architecture:

A RAID 10 array consists of multiple mirror pairs. Each pair contains identical copies of data. Writes go to both drives in a pair; reads can come from either. The pairs are then striped to distribute data and I/O load across the array.

RAID 10 Fault Tolerance Nuance:

RAID 10 can survive multiple failures, but with critical caveats:

• Best case: Lose one drive from each mirror pair → all data survives
• Worst case: Lose both drives in any single pair → complete data loss

With a 6-drive RAID 10, you can survive 1, 2, or even 3 failures—as long as no mirror pair loses both drives. This means RAID 10 can be more or less reliable than RAID 6 depending on failure patterns:

Why RAID 10 for Databases:

RAID 10 is the gold standard for database workloads because:

1. No write penalty: Writes are simple mirrors; no parity calculation
2. Consistent latency: No degraded-mode performance cliff
3. Fast rebuild: Only copies one drive; doesn't stress entire array
4. Predictable performance: Linear scaling with drive count
5. Simple failure analysis: Easy to understand which failures are survivable

The capacity cost is the only significant drawback—you lose 50% of raw capacity. For high-performance OLTP databases where IOPS matter more than capacity, this tradeoff is almost always worthwhile.

The following comprehensive comparison consolidates the key characteristics of each RAID level to facilitate selection decisions.

Capacity Efficiency vs. Drive Count:

Parity-based RAID becomes more capacity-efficient as you add drives:

For large arrays (12+ drives), RAID 6 approaches RAID 10's capacity efficiency while providing superior fault tolerance. However, the write penalty remains, making RAID 10 superior for write-intensive workloads regardless of array size.

We've examined the five major RAID levels in depth. Here are the key decision factors:

What's Next:

With solid understanding of RAID levels, we'll now examine their performance characteristics in greater depth. The next page provides detailed performance analysis, including benchmarking methodologies, real-world performance patterns, and optimization strategies for database workloads.