N, W, R Parameters

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

-- N: Replication Factor set at keyspace creation
CREATE KEYSPACE financial_data
WITH REPLICATION = {
  'class': 'NetworkTopologyStrategy',
  'datacenter1': 3,   -- N=3 in datacenter1
  'datacenter2': 3    -- N=3 in datacenter2 (total 6 replicas)
};
 
-- W: Write consistency level (can be set per query)
-- Writing with QUORUM (majority): W = floor(N/2) + 1 = 2
INSERT INTO accounts (id, balance) VALUES ('user-123', 10000)
USING CONSISTENCY QUORUM;
 
-- W: Writing to ALL replicas (W = N = 3)
INSERT INTO critical_config (key, value) VALUES ('rate_limit', '100')
USING CONSISTENCY ALL;
 
-- W: Writing with acknowledgment from any single node (W = 1)
INSERT INTO access_logs (user_id, timestamp, action) VALUES ('user-123', now(), 'login')
USING CONSISTENCY ONE;
 
-- R: Read consistency level (can be set per query)
-- Reading with QUORUM: R = floor(N/2) + 1 = 2
SELECT balance FROM accounts WHERE id = 'user-123'
USING CONSISTENCY QUORUM;
 
-- R: Reading from ONE replica (fast but potentially stale)
SELECT timestamp FROM access_logs WHERE user_id = 'user-123'
USING CONSISTENCY ONE;
 
-- Combined: Strong consistency requires W + R > N
-- With N=3, W=QUORUM(2), R=QUORUM(2): 2+2=4 > 3 ✓ Strong consistency
-- With N=3, W=ONE(1), R=ONE(1): 1+1=2 < 3 ✗ Eventual consistency

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

interface QuorumAnalysis {
  // Input parameters
  n: number;
  w: number;
  r: number;
  
  // Consistency analysis
  hasStrongConsistency: boolean;
  minOverlap: number;
  
  // Availability analysis
  writesAvailableWithFailures: number;
  readsAvailableWithFailures: number;
  
  // Recommendations
  consistencyLevel: 'strong' | 'eventual' | 'invalid';
  warnings: string[];
}
 
function analyzeQuorum(n: number, w: number, r: number): QuorumAnalysis {
  const warnings: string[] = [];
  
  // Validate inputs
  if (w > n) warnings.push(`W(${w}) cannot exceed N(${n})`);
  if (r > n) warnings.push(`R(${r}) cannot exceed N(${n})`);
  if (w < 1) warnings.push('W must be at least 1');
  if (r < 1) warnings.push('R must be at least 1');
  
  const hasStrongConsistency = w + r > n;
  const minOverlap = Math.max(0, w + r - n);
  
  // Failure tolerance
  const writesAvailableWithFailures = n - w;
  const readsAvailableWithFailures = n - r;
  
  // Warnings for edge cases
  if (w === n) {
    warnings.push('W=N: Any node failure will block writes');
  }
  if (r === n) {
    warnings.push('R=N: Any node failure will block reads');
  }
  if (w === 1 && hasStrongConsistency) {
    warnings.push('W=1 with strong consistency requires R=N; single node failure blocks reads');
  }
  
  let consistencyLevel: 'strong' | 'eventual' | 'invalid';
  if (w > n || r > n || w < 1 || r < 1) {
    consistencyLevel = 'invalid';
  } else if (hasStrongConsistency) {
    consistencyLevel = 'strong';
  } else {
    consistencyLevel = 'eventual';
  }
  
  return {
    n, w, r,
    hasStrongConsistency,
    minOverlap,
    writesAvailableWithFailures,
    readsAvailableWithFailures,
    consistencyLevel,
    warnings,
  };
}
 
// Example usage:
console.log(analyzeQuorum(5, 3, 3));
/* Output:
{
  n: 5, w: 3, r: 3,
  hasStrongConsistency: true,
  minOverlap: 1,
  writesAvailableWithFailures: 2,
  readsAvailableWithFailures: 2,
  consistencyLevel: 'strong',
  warnings: []
}
*/
 
console.log(analyzeQuorum(5, 2, 2));
/* Output:
{
  n: 5, w: 2, r: 2,
  hasStrongConsistency: false,
  minOverlap: 0,
  writesAvailableWithFailures: 3,
  readsAvailableWithFailures: 3,
  consistencyLevel: 'eventual',
  warnings: []
}
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// Simulate quorum latency based on node response times
function simulateQuorumLatency(
  nodeLatencies: number[],  // Array of latencies from each node
  quorum: number            // Number of responses needed
): number {
  // Sort latencies ascending
  const sorted = [...nodeLatencies].sort((a, b) => a - b);
  
  // Quorum is achieved when we get the q-th response
  // (0-indexed, so quorum-1)
  return sorted[quorum - 1];
}
 
// Example: 5 nodes with varying latencies
const nodeSpeeds = [10, 25, 50, 100, 500];  // ms (one slow node!)
 
console.log(`W=1: ${simulateQuorumLatency(nodeSpeeds, 1)}ms`);  // 10ms
console.log(`W=2: ${simulateQuorumLatency(nodeSpeeds, 2)}ms`);  // 25ms
console.log(`W=3: ${simulateQuorumLatency(nodeSpeeds, 3)}ms`);  // 50ms
console.log(`W=4: ${simulateQuorumLatency(nodeSpeeds, 4)}ms`);  // 100ms
console.log(`W=5: ${simulateQuorumLatency(nodeSpeeds, 5)}ms`);  // 500ms (!)
 
// Monte Carlo simulation for p99 latency
function simulateP99Latency(
  baseLatency: number,
  variance: number,
  nodeCount: number,
  quorum: number,
  iterations: number = 10000
): number {
  const latencies: number[] = [];
  
  for (let i = 0; i < iterations; i++) {
    // Generate random latencies for each node
    const nodeLatencies = Array(nodeCount).fill(0).map(() =>
      baseLatency + (Math.random() * variance * 2 - variance)
    );
    
    latencies.push(simulateQuorumLatency(nodeLatencies, quorum));
  }
  
  latencies.sort((a, b) => a - b);
  return latencies[Math.floor(iterations * 0.99)];  // p99
}
 
// Compare p99 latencies for different quorum settings
const base = 20;   // ms base latency
const variance = 10;  // ms variance
 
console.log('P99 Latencies:');
console.log(`W=2: ${simulateP99Latency(base, variance, 5, 2).toFixed(1)}ms`);
console.log(`W=3: ${simulateP99Latency(base, variance, 5, 3).toFixed(1)}ms`);
console.log(`W=4: ${simulateP99Latency(base, variance, 5, 4).toFixed(1)}ms`);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

enum ConsistencyLevel {
  ONE = 'ONE',           // W or R = 1
  QUORUM = 'QUORUM',     // W or R = floor(N/2) + 1
  ALL = 'ALL',           // W or R = N
  LOCAL_ONE = 'LOCAL_ONE',      // 1 in local datacenter
  LOCAL_QUORUM = 'LOCAL_QUORUM', // Quorum in local datacenter
  EACH_QUORUM = 'EACH_QUORUM',   // Quorum in each datacenter
}
 
interface QueryOptions {
  consistency: ConsistencyLevel;
  timeout?: number;
  retryPolicy?: RetryPolicy;
}
 
class FinancialService {
  // Critical: Account balances require strong consistency
  async getBalance(accountId: string): Promise<number> {
    return this.db.read(
      'SELECT balance FROM accounts WHERE id = ?',
      [accountId],
      { consistency: ConsistencyLevel.QUORUM }  // R=2
    );
  }
  
  async updateBalance(accountId: string, newBalance: number): Promise<void> {
    await this.db.write(
      'UPDATE accounts SET balance = ? WHERE id = ?',
      [newBalance, accountId],
      { consistency: ConsistencyLevel.QUORUM }  // W=2
      // Combined: 2+2 = 4 > 3 = N → Strong consistency
    );
  }
  
  // Less critical: Transaction history can be slightly stale
  async getTransactionHistory(accountId: string): Promise<Transaction[]> {
    return this.db.read(
      'SELECT * FROM transactions WHERE account_id = ? ORDER BY timestamp DESC',
      [accountId],
      { consistency: ConsistencyLevel.ONE }  // R=1 for speed
    );
  }
}
 
class LoggingService {
  // High volume, low criticality: Fire and forget
  async logEvent(event: LogEvent): Promise<void> {
    await this.db.write(
      'INSERT INTO events (id, type, data, timestamp) VALUES (?, ?, ?, ?)',
      [event.id, event.type, event.data, event.timestamp],
      { 
        consistency: ConsistencyLevel.ONE,  // W=1
        timeout: 50  // Fail fast
      }
    );
  }
}
 
class ConfigService {
  // Critical infrastructure: Maximum durability and freshness
  async getConfig(key: string): Promise<string> {
    return this.db.read(
      'SELECT value FROM configs WHERE key = ?',
      [key],
      { consistency: ConsistencyLevel.ALL }  // R=N
    );
  }
  
  async setConfig(key: string, value: string): Promise<void> {
    await this.db.write(
      'UPDATE configs SET value = ? WHERE key = ?',
      [value, key],
      { consistency: ConsistencyLevel.ALL }  // W=N
    );
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

interface DatacenterTopology {
  name: string;
  replicationFactor: number;
  nodes: Node[];
}
 
interface MultiDCQuorumConfig {
  datacenters: DatacenterTopology[];
  globalReplicationFactor: number;  // Sum of all DC replication factors
}
 
function calculateLocalQuorum(dcReplicationFactor: number): number {
  return Math.floor(dcReplicationFactor / 2) + 1;
}
 
function calculateGlobalQuorum(globalN: number): number {
  return Math.floor(globalN / 2) + 1;
}
 
// Example: 2 datacenters with RF=3 each
const topology: MultiDCQuorumConfig = {
  datacenters: [
    { name: 'us-east', replicationFactor: 3, nodes: ['A', 'B', 'C'] },
    { name: 'us-west', replicationFactor: 3, nodes: ['D', 'E', 'F'] },
  ],
  globalReplicationFactor: 6,
};
 
// Consistency levels and their behavior
const consistencyLevels = {
  ONE: {
    description: 'Single node acknowledgment',
    nodes: 1,
    latency: 'Lowest',
    consistency: 'Weakest'
  },
  LOCAL_ONE: {
    description: 'Single node in local DC',
    nodes: 1,
    latency: 'Very low (no cross-DC)',
    consistency: 'Weak but fast'
  },
  LOCAL_QUORUM: {
    description: 'Quorum in local DC only',
    nodesNeeded: calculateLocalQuorum(3),  // = 2
    latency: 'Low (no cross-DC)',
    consistency: 'Strong within DC'
  },
  QUORUM: {
    description: 'Global quorum across all DCs',
    nodesNeeded: calculateGlobalQuorum(6),  // = 4
    latency: 'High (must cross DC)',
    consistency: 'Strong globally'
  },
  EACH_QUORUM: {
    description: 'Quorum in EVERY datacenter',
    nodesNeeded: 2 + 2,  // 2 in each DC
    latency: 'Highest (all DCs required)',
    consistency: 'Strongest (survives DC failure)'
  },
  ALL: {
    description: 'All nodes must acknowledge',
    nodesNeeded: 6,
    latency: 'Highest possible',
    consistency: 'Maximum durability'
  },
};
 
// Latency analysis
console.log('Latency comparison:');
console.log('LOCAL_QUORUM (2 local nodes): ~5-10ms');
console.log('QUORUM (4 nodes, likely cross-DC): ~50-150ms');
console.log('EACH_QUORUM (2 per DC): ~50-150ms');
console.log('ALL (6 nodes): ~75-200ms');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

interface DataCharacteristics {
  isCritical: boolean;          // Can the business survive data loss?
  dataSize: 'small' | 'medium' | 'large' | 'massive';
  writeVolume: 'low' | 'medium' | 'high';
  readPattern: 'balanced' | 'read-heavy' | 'write-heavy';
  geographicRequirements: 'single-region' | 'multi-region' | 'global';
  budgetConstraint: 'low' | 'medium' | 'high';
}
 
function recommendReplicationFactor(data: DataCharacteristics): {
  recommendedN: number;
  reasoning: string[];
} {
  const reasoning: string[] = [];
  let n = 3; // Default starting point
  
  // Criticality adjustment
  if (data.isCritical) {
    n = Math.max(n, 5);
    reasoning.push('Critical data: Starting at N=5 for maximum protection');
  }
  
  // Size/cost adjustment
  if (data.dataSize === 'massive' && data.budgetConstraint === 'low') {
    n = Math.min(n, 3);
    reasoning.push('Large data + budget constraint: Capping at N=3');
  }
  
  // Geographic requirements
  if (data.geographicRequirements === 'multi-region') {
    n = Math.max(n, 4);  // At least 2 per region for 2 regions
    reasoning.push('Multi-region: Need at least N=4 (2 per region)');
  } else if (data.geographicRequirements === 'global') {
    n = Math.max(n, 6);  // At least 2 per region for 3+ regions
    reasoning.push('Global: Need at least N=6 (2 per region for 3 regions)');
  }
  
  // Read scalability
  if (data.readPattern === 'read-heavy' && data.writeVolume === 'low') {
    n = Math.max(n, 5);
    reasoning.push('Read-heavy: Higher N provides more read replicas');
  }
  
  // Write volume consideration
  if (data.writeVolume === 'high' && data.dataSize === 'large') {
    n = Math.min(n, 3);
    reasoning.push('High write volume + large data: Limiting N to control write amplification');
  }
  
  // Ensure odd number for clean majority quorums
  if (n % 2 === 0 && n > 2) {
    n += 1;
    reasoning.push(`Adjusted to odd number N=${n} for clean majority quorum`);
  }
  
  return { recommendedN: n, reasoning };
}
 
// Example usage
const recommendation = recommendReplicationFactor({
  isCritical: true,
  dataSize: 'medium',
  writeVolume: 'medium',
  readPattern: 'read-heavy',
  geographicRequirements: 'multi-region',
  budgetConstraint: 'medium',
});
 
console.log(`Recommended N: ${recommendation.recommendedN}`);
recommendation.reasoning.forEach(r => console.log(`  - ${r}`));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

-- PATTERN 1: Standard Strong Consistency
-- Most common production configuration
CREATE KEYSPACE transactional_data
WITH REPLICATION = { 'class': 'SimpleStrategy', 'replication_factor': 3 };
 
-- Write: QUORUM (2), Read: QUORUM (2)
-- 2 + 2 = 4 > 3 → Strong consistency
-- Tolerates 1 node failure for both reads and writes
 
-- PATTERN 2: Read-Heavy Workload
-- News sites, content platforms, product catalogs
CREATE KEYSPACE content_data
WITH REPLICATION = { 'class': 'SimpleStrategy', 'replication_factor': 3 };
 
-- Write: ALL (3), Read: ONE (1)  
-- 3 + 1 = 4 > 3 → Strong consistency
-- Writes are rare but durable; reads are fast
-- Warning: Any node failure blocks writes
 
-- PATTERN 3: Write-Heavy Workload
-- Logging, metrics, event streaming
CREATE KEYSPACE event_data
WITH REPLICATION = { 'class': 'SimpleStrategy', 'replication_factor': 3 };
 
-- Write: ONE (1), Read: ONE (1)
-- 1 + 1 = 2 < 3 → Eventual consistency (acceptable for logs)
-- Maximum write throughput and availability
 
-- PATTERN 4: Multi-Datacenter (Local + Remote)
CREATE KEYSPACE global_data
WITH REPLICATION = {
  'class': 'NetworkTopologyStrategy',
  'us-east': 3,
  'eu-west': 3
};
 
-- Write: LOCAL_QUORUM, Read: LOCAL_QUORUM
-- Fast local operations, async cross-DC replication
-- During DC failure: may see stale data from surviving DC
 
-- PATTERN 5: Multi-Datacenter (Strict Consistency)
CREATE KEYSPACE critical_financial_data
WITH REPLICATION = {
  'class': 'NetworkTopologyStrategy',
  'us-east': 3,
  'eu-west': 3
};
 
-- Write: EACH_QUORUM, Read: QUORUM
-- Every write confirmed in both DCs
-- Higher latency but survives full DC failure with consistency