Database Replication

Replication maintains copies of data on multiple nodes for availability, durability, and read scalability.

Master-Slave Replication

class MasterSlaveReplication {
  private master: DatabaseConnection;
  private slaves: DatabaseConnection[];
  private currentSlaveIndex: number = 0;

  async write(query: string): Promise {
    // All writes go to master
    await this.master.execute(query);

    // Async replication to slaves
    this.slaves.forEach(slave => {
      slave.replicate(query).catch(err => {
        console.error('Replication failed:', err);
      });
    });
  }

  async read(query: string): Promise {
    // Round-robin read from slaves
    const slave = this.slaves[this.currentSlaveIndex];
    this.currentSlaveIndex = (this.currentSlaveIndex + 1) % this.slaves.length;
    return slave.execute(query);
  }

  async readFromMaster(query: string): Promise {
    // For read-after-write consistency
    return this.master.execute(query);
  }
}

Quorum-Based Replication

class QuorumReplication {
  private nodes: DatabaseConnection[];
  private n: number; // Total nodes
  private w: number; // Write quorum
  private r: number; // Read quorum

  constructor(nodes: DatabaseConnection[], w: number, r: number) {
    this.nodes = nodes;
    this.n = nodes.length;
    this.w = w;
    this.r = r;

    // Strong consistency: W + R > N
    if (w + r <= this.n) {
      console.warn('Warning: W + R <= N, consistency not guaranteed');
    }
  }

  async write(key: string, value: any): Promise {
    const writePromises = this.nodes.map(node =>
      node.write(key, value).then(() => true).catch(() => false)
    );

    const results = await Promise.all(writePromises);
    const successCount = results.filter(Boolean).length;

    if (successCount >= this.w) {
      console.log(`Write successful: ${successCount}/${this.n} nodes`);
      return true;
    }

    throw new Error(`Write failed: only ${successCount}/${this.w} required acks`);
  }

  async read(key: string): Promise {
    const readPromises = this.nodes.map(node =>
      node.read(key).catch(() => null)
    );

    const results = await Promise.all(readPromises);
    const validResults = results.filter(r => r !== null);

    if (validResults.length >= this.r) {
      // Return the most recent value
      return this.getMostRecent(validResults);
    }

    throw new Error(`Read failed: only ${validResults.length}/${this.r} required responses`);
  }

  private getMostRecent(results: any[]): any {
    return results.reduce((latest, current) =>
      current.timestamp > latest.timestamp ? current : latest
    );
  }
}

// Common configurations:
// N=3, W=2, R=2: Strong consistency
// N=3, W=1, R=1: High availability, eventual consistency
// N=3, W=3, R=1: Write-heavy with strong writes

Replication Patterns

Replication Patterns

Database Replication

Master-Slave Replication

Quorum-Based Replication