Databases

const PARTITIONS = 4;

type Row = { id: string; customer: string; day: string; status: string };
type Field = keyof Row;

// A stand-in for the hash a partitioned store (DynamoDB, Cassandra, Spanner splits) uses to place a key.
function partitionOf(key: string): number {
  let sum = 0;
  for (const ch of key) sum += ch.charCodeAt(0);
  return sum % PARTITIONS;
}

class PartitionedTable {
  parts: Row[][] = Array.from({ length: PARTITIONS }, () => []);
  constructor(readonly partitionKey: Field) {}

  put(row: Row): void {
    this.parts[partitionOf(row[this.partitionKey])].push(row);
  }

  // Partition key given: the store goes straight to one partition.
  queryByKey(value: string): [Row[], number] {
    return [this.parts[partitionOf(value)].filter((r) => r[this.partitionKey] === value), 1];
  }

  // Any other field: every partition must be asked (scatter-gather).
  scanWhere(field: Field, value: string): [Row[], number] {
    return [this.parts.flat().filter((r) => r[field] === value), PARTITIONS];
  }

  sizes(): string {
    return `[${this.parts.map((p) => p.length).join(", ")}]`;
  }
}

const ORDERS: Row[] = [];
for (let i = 0; i < 12; i++) {
  const day = i >= 6 ? "2026-11-03" : `2026-11-0${1 + (i % 2)}`; // half the orders are from today
  ORDERS.push({ id: `o${i}`, customer: `cust${i % 5}`, day, status: i % 4 === 0 ? "late" : "ok" });
}

const byCustomer = new PartitionedTable("customer");
ORDERS.forEach((o) => byCustomer.put(o));

let [rows, asked] = byCustomer.queryByKey("cust2");
console.log(`orders of cust2: ${rows.length} rows, asked ${asked} of ${PARTITIONS} partitions`);
[rows, asked] = byCustomer.scanWhere("status", "late");
console.log(`late orders: ${rows.length} rows, asked ${asked} of ${PARTITIONS} partitions`);

// A global secondary index is a second table keyed by the other field, kept in step by the store.
const byStatus = new PartitionedTable("status");
ORDERS.forEach((o) => byStatus.put(o));
[rows, asked] = byStatus.queryByKey("late");
console.log(`late orders via an index: ${rows.length} rows, asked ${asked} of ${PARTITIONS} partitions`);

console.log("rows per partition, keyed by customer:", byCustomer.sizes());
const byDay = new PartitionedTable("day");
ORDERS.forEach((o) => byDay.put(o));
console.log("rows per partition, keyed by day:", byDay.sizes());
const today = ORDERS.filter((o) => o.day === "2026-11-03").length;
console.log(`today's ${today} writes all land on partition ${partitionOf("2026-11-03")}: a hot partition`);

import java.util.*;

public class Main {
    static final int PARTITIONS = 4;

    record Row(String id, String customer, String day, String status) {
        String get(String field) {
            return switch (field) {
                case "customer" -> customer;
                case "day" -> day;
                case "status" -> status;
                default -> id;
            };
        }
    }

    // A stand-in for the hash a partitioned store (DynamoDB, Cassandra, Spanner splits) uses to place a key.
    static int partitionOf(String key) {
        int sum = 0;
        for (char ch : key.toCharArray()) sum += ch;
        return sum % PARTITIONS;
    }

    static class PartitionedTable {
        final String partitionKey;
        final List<List<Row>> parts = new ArrayList<>();

        PartitionedTable(String partitionKey) {
            this.partitionKey = partitionKey;
            for (int i = 0; i < PARTITIONS; i++) parts.add(new ArrayList<>());
        }

        void put(Row row) {
            parts.get(partitionOf(row.get(partitionKey))).add(row);
        }

        // Partition key given: the store goes straight to one partition.
        int queryByKey(String value) {
            return (int) parts.get(partitionOf(value)).stream().filter(r -> r.get(partitionKey).equals(value)).count();
        }

        // Any other field: every partition must be asked (scatter-gather).
        int scanWhere(String field, String value) {
            return (int) parts.stream().flatMap(List::stream).filter(r -> r.get(field).equals(value)).count();
        }

        String sizes() {
            return parts.stream().map(p -> String.valueOf(p.size())).toList().toString();
        }
    }

    public static void main(String[] args) {
        List<Row> orders = new ArrayList<>();
        for (int i = 0; i < 12; i++) {
            String day = i >= 6 ? "2026-11-03" : "2026-11-0" + (1 + i % 2); // half the orders are from today
            orders.add(new Row("o" + i, "cust" + (i % 5), day, i % 4 == 0 ? "late" : "ok"));
        }

        PartitionedTable byCustomer = new PartitionedTable("customer");
        orders.forEach(byCustomer::put);
        System.out.printf("orders of cust2: %d rows, asked 1 of %d partitions%n", byCustomer.queryByKey("cust2"), PARTITIONS);
        System.out.printf("late orders: %d rows, asked %d of %d partitions%n", byCustomer.scanWhere("status", "late"), PARTITIONS, PARTITIONS);

        // A global secondary index is a second table keyed by the other field, kept in step by the store.
        PartitionedTable byStatus = new PartitionedTable("status");
        orders.forEach(byStatus::put);
        System.out.printf("late orders via an index: %d rows, asked 1 of %d partitions%n", byStatus.queryByKey("late"), PARTITIONS);

        System.out.println("rows per partition, keyed by customer: " + byCustomer.sizes());
        PartitionedTable byDay = new PartitionedTable("day");
        orders.forEach(byDay::put);
        System.out.println("rows per partition, keyed by day: " + byDay.sizes());
        long today = orders.stream().filter(o -> o.day().equals("2026-11-03")).count();
        System.out.printf("today's %d writes all land on partition %d: a hot partition%n", today, partitionOf("2026-11-03"));
    }
}