// === MongoDB（ドキュメント型）===
// 柔軟なスキーマで入れ子構造を自然に表現
db.users.insertOne({
  _id: ObjectId("..."),
  name: "Taro",
  email: "taro@example.com",
  address: {
    city: "Tokyo",
    zip: "100-0001",
    prefecture: "東京都"
  },
  orders: [
    { product: "Widget", amount: 1200, date: ISODate("2026-02-01") },
    { product: "Gadget", amount: 3400, date: ISODate("2026-02-10") }
  ],
  tags: ["premium", "early-adopter"],
  metadata: {
    loginCount: 42,
    lastLoginAt: ISODate("2026-02-13"),
    preferences: {
      theme: "dark",
      language: "ja",
      notifications: { email: true, push: false }
    }
  }
});
 
// ドキュメントの検索（リッチなクエリ言語）
db.users.find({
  "address.city": "Tokyo",
  "orders.amount": { $gt: 2000 },
  tags: { $in: ["premium"] }
}).sort({ "metadata.lastLoginAt": -1 });

# === Redis（Key-Value 型）===
import redis
r = redis.Redis()
 
# シンプルな KV
r.set("user:1:name", "Taro")
r.get("user:1:name")  # → b"Taro"
 
# Hash（オブジェクト風）
r.hset("user:1", mapping={
    "name": "Taro",
    "email": "taro@example.com",
    "login_count": 42
})
r.hgetall("user:1")  # → {b"name": b"Taro", ...}
 
# Sorted Set でランキング
r.zadd("leaderboard", {"user:1": 1500, "user:2": 2300, "user:3": 800})
r.zrevrange("leaderboard", 0, 9, withscores=True)  # Top 10
 
# List でメッセージキュー
r.lpush("queue:emails", '{"to": "taro@example.com", "subject": "Welcome"}')
r.brpop("queue:emails", timeout=30)  # ブロッキング取得
 
# Set で集合演算
r.sadd("user:1:interests", "python", "sql", "redis")
r.sadd("user:2:interests", "python", "mongodb", "go")
r.sinter("user:1:interests", "user:2:interests")  # → {b"python"}
 
# Stream でイベントストリーミング（Redis 5.0+）
r.xadd("events:orders", {"action": "created", "order_id": "123"})
r.xread({"events:orders": "0"}, count=10)
 
# HyperLogLog でカーディナリティ推定
r.pfadd("daily_visitors:2026-02-13", "user:1", "user:2", "user:3")
r.pfcount("daily_visitors:2026-02-13")  # → 3（推定値）

# === DynamoDB（ワイドカラム型）===
import boto3
from decimal import Decimal
 
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('MyApp')
 
# Single Table Design: 1テーブルに複数エンティティを格納
# PK（パーティションキー）+ SK（ソートキー）の複合キー
 
# ユーザープロフィール
table.put_item(Item={
    'PK': 'USER#001',
    'SK': 'PROFILE',
    'name': 'Taro',
    'email': 'taro@example.com',
    'created_at': '2026-01-01T00:00:00Z',
    'GSI1PK': 'USER',  # GSI用
    'GSI1SK': 'taro@example.com'
})
 
# ユーザーの注文
table.put_item(Item={
    'PK': 'USER#001',
    'SK': 'ORDER#2026-02-01#001',
    'product': 'Widget',
    'amount': Decimal('1200'),
    'status': 'shipped'
})
 
# クエリ: ユーザー001の全データ（プロフィール + 注文）
response = table.query(
    KeyConditionExpression='PK = :pk',
    ExpressionAttributeValues={':pk': 'USER#001'}
)
 
# クエリ: ユーザー001の2026年2月の注文のみ
response = table.query(
    KeyConditionExpression='PK = :pk AND begins_with(SK, :sk_prefix)',
    ExpressionAttributeValues={
        ':pk': 'USER#001',
        ':sk_prefix': 'ORDER#2026-02'
    }
)

// === Neo4j（グラフ型）===
// Cypher クエリ言語
 
// ノードとリレーションの作成
CREATE (taro:User {name: "Taro", email: "taro@example.com"})
CREATE (hanako:User {name: "Hanako", email: "hanako@example.com"})
CREATE (python:Skill {name: "Python"})
CREATE (sql:Skill {name: "SQL"})
CREATE (taro)-[:KNOWS]->(hanako)
CREATE (taro)-[:HAS_SKILL {level: "expert"}]->(python)
CREATE (taro)-[:HAS_SKILL {level: "intermediate"}]->(sql)
CREATE (hanako)-[:HAS_SKILL {level: "expert"}]->(sql)
 
// 友達の友達（2ホップ探索）
MATCH (u:User {name: "Taro"})-[:KNOWS*2]->(fof:User)
WHERE fof <> u
RETURN DISTINCT fof.name
 
// 共通スキルを持つユーザーの推薦
MATCH (u:User {name: "Taro"})-[:HAS_SKILL]->(s:Skill)<-[:HAS_SKILL]-(other:User)
WHERE other <> u
RETURN other.name, collect(s.name) AS shared_skills, count(s) AS skill_count
ORDER BY skill_count DESC

// MongoDB: 読み取り一貫性の設定
// 強い整合性（プライマリから読み取り）
db.orders.find({ userId: "001" }).readConcern("majority");
 
// 結果整合性（セカンダリから読み取り、高速）
db.orders.find({ userId: "001" }).readPref("secondaryPreferred");
 
// 因果一貫性（セッション内）
const session = db.getMongo().startSession({ causalConsistency: true });
const orders = session.getDatabase("mydb").orders;
orders.insertOne({ userId: "001", product: "Widget" });
// 同じセッション内では必ず上記の挿入結果が見える
orders.find({ userId: "001" });
session.endSession();
 
// 書き込み確認レベル
db.orders.insertOne(
  { userId: "001", product: "Widget" },
  { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
);
// w: "majority" → 過半数のレプリカに書き込み完了を確認
// j: true → ジャーナルへの書き込みを確認
// wtimeout: 5000 → 5秒以内に完了しなければエラー

# DynamoDB: 読み取り一貫性の設定
import boto3
table = boto3.resource('dynamodb').Table('MyApp')
 
# 強い整合性（RCU 2倍消費）
response = table.get_item(
    Key={'PK': 'USER#001', 'SK': 'PROFILE'},
    ConsistentRead=True
)
 
# 結果整合性（デフォルト、RCU 半分）
response = table.get_item(
    Key={'PK': 'USER#001', 'SK': 'PROFILE'},
    ConsistentRead=False
)
 
# DynamoDB トランザクション（ACID保証）
client = boto3.client('dynamodb')
client.transact_write_items(
    TransactItems=[
        {
            'Put': {
                'TableName': 'MyApp',
                'Item': {
                    'PK': {'S': 'ORDER#123'},
                    'SK': {'S': 'DETAIL'},
                    'status': {'S': 'confirmed'},
                    'amount': {'N': '5000'}
                },
                'ConditionExpression': 'attribute_not_exists(PK)'
            }
        },
        {
            'Update': {
                'TableName': 'MyApp',
                'Key': {
                    'PK': {'S': 'USER#001'},
                    'SK': {'S': 'PROFILE'}
                },
                'UpdateExpression': 'SET order_count = order_count + :inc',
                'ExpressionAttributeValues': {':inc': {'N': '1'}}
            }
        }
    ]
)

# Cassandra: 一貫性レベルの設定
from cassandra.cluster import Cluster
from cassandra import ConsistencyLevel
from cassandra.query import SimpleStatement
 
cluster = Cluster(['node1', 'node2', 'node3'])
session = cluster.connect('mykeyspace')
 
# 強い整合性（QUORUM: 過半数のノードから応答）
statement = SimpleStatement(
    "SELECT * FROM orders WHERE user_id = %s",
    consistency_level=ConsistencyLevel.QUORUM
)
rows = session.execute(statement, ['user001'])
 
# 結果整合性（ONE: 1ノードから応答、最も高速）
statement = SimpleStatement(
    "SELECT * FROM orders WHERE user_id = %s",
    consistency_level=ConsistencyLevel.ONE
)
 
# ALL: 全ノードから応答（最も遅いが最も一貫性が高い）
statement = SimpleStatement(
    "SELECT * FROM orders WHERE user_id = %s",
    consistency_level=ConsistencyLevel.ALL
)

# ポリグロット永続化のサービス例
class OrderService:
    def __init__(self):
        self.pg = PostgresClient()       # トランザクション処理
        self.redis = RedisClient()       # キャッシュ
        self.mongo = MongoClient()       # 注文履歴（非正規化）
        self.es = ElasticsearchClient()  # 検索
 
    async def create_order(self, order_data):
        # 1. PostgreSQL でトランザクション処理（Source of Truth）
        async with self.pg.transaction() as tx:
            order = await tx.execute("""
                INSERT INTO orders (user_id, total, status)
                VALUES ($1, $2, 'pending')
                RETURNING id, created_at
            """, order_data['user_id'], order_data['total'])
 
            # 在庫の減算（同一トランザクション）
            for item in order_data['items']:
                await tx.execute("""
                    UPDATE products SET stock = stock - $1
                    WHERE id = $2 AND stock >= $1
                """, item['quantity'], item['product_id'])
 
        # 2. MongoDB に非正規化データを保存（高速読み取り用）
        await self.mongo.orders.insert_one({
            'order_id': order['id'],
            'user': order_data['user'],  # ユーザー情報を埋め込み
            'items': order_data['items'],  # 商品情報を埋め込み
            'total': order_data['total'],
            'status': 'pending',
            'created_at': order['created_at'],
        })
 
        # 3. Redis キャッシュを無効化
        await self.redis.delete(f"user:{order_data['user_id']}:orders")
        await self.redis.delete(f"user:{order_data['user_id']}:order_count")
 
        # 4. Elasticsearch にインデックス（非同期でも可）
        await self.es.index('orders', {
            'order_id': order['id'],
            'user_name': order_data['user']['name'],
            'items': [i['name'] for i in order_data['items']],
            'total': order_data['total'],
            'status': 'pending',
            'created_at': order['created_at'],
        })
 
        return order
 
    async def get_order_history(self, user_id, page=1, per_page=20):
        # キャッシュチェック
        cache_key = f"user:{user_id}:orders:page:{page}"
        cached = await self.redis.get(cache_key)
        if cached:
            return json.loads(cached)
 
        # MongoDB から読み取り（非正規化データ、JOIN不要で高速）
        orders = await self.mongo.orders.find(
            {'user.id': user_id}
        ).sort('created_at', -1).skip((page - 1) * per_page).limit(per_page).to_list()
 
        # キャッシュに保存（5分間有効）
        await self.redis.setex(cache_key, 300, json.dumps(orders))
 
        return orders
 
    async def search_orders(self, query, filters=None):
        # Elasticsearch で全文検索
        body = {
            'query': {
                'bool': {
                    'must': [
                        {'multi_match': {
                            'query': query,
                            'fields': ['items', 'user_name']
                        }}
                    ]
                }
            }
        }
        if filters:
            body['query']['bool']['filter'] = filters
 
        return await self.es.search(index='orders', body=body)

// MongoDB のパイプライン集計（RDBのGROUP BY + JOIN相当）
db.orders.aggregate([
  // Stage 1: フィルタ（WHERE相当）
  { $match: {
    status: "shipped",
    createdAt: { $gte: ISODate("2026-01-01") }
  }},
 
  // Stage 2: 配列の展開（UNNEST相当）
  { $unwind: "$items" },
 
  // Stage 3: グループ集計（GROUP BY相当）
  { $group: {
      _id: "$items.category",
      totalRevenue: { $sum: "$items.price" },
      orderCount: { $sum: 1 },
      avgPrice: { $avg: "$items.price" },
      maxPrice: { $max: "$items.price" },
      uniqueProducts: { $addToSet: "$items.productId" }
  }},
 
  // Stage 4: 計算フィールドの追加
  { $addFields: {
    uniqueProductCount: { $size: "$uniqueProducts" },
    avgOrderValue: { $divide: ["$totalRevenue", "$orderCount"] }
  }},
 
  // Stage 5: ソート（ORDER BY相当）
  { $sort: { totalRevenue: -1 } },
 
  // Stage 6: リミット
  { $limit: 10 },
 
  // Stage 7: 結果の整形
  { $project: {
    category: "$_id",
    totalRevenue: { $round: ["$totalRevenue", 2] },
    orderCount: 1,
    avgPrice: { $round: ["$avgPrice", 2] },
    uniqueProductCount: 1,
    _id: 0
  }}
]);
 
// $lookup: JOIN相当（ただしNoSQLでは非推奨パターン）
db.orders.aggregate([
  { $lookup: {
    from: "users",
    localField: "userId",
    foreignField: "_id",
    as: "user"
  }},
  { $unwind: "$user" },
  { $project: {
    orderId: "$_id",
    userName: "$user.name",
    total: 1,
    status: 1
  }}
]);
// ※ $lookupはシャーディング環境でパフォーマンスが劣化する
// → 非正規化（embedding）で回避すべき

-- RDB: 正規化モデル（4テーブル + JOIN）
-- 第3正規形: データの重複なし、更新異常なし
SELECT
    u.name,
    o.id AS order_id,
    o.order_date,
    p.name AS product_name,
    p.category,
    oi.quantity,
    oi.unit_price
FROM users u
JOIN orders o ON u.id = o.user_id
JOIN order_items oi ON o.id = oi.order_id
JOIN products p ON oi.product_id = p.id
WHERE u.id = 12345;
-- 4テーブル結合 → 複雑だが、データの整合性が保証される

// MongoDB: 非正規化モデル（1ドキュメントで完結）
// データの重複はあるが、読み取りが高速
db.orders.findOne({
  userId: 12345
}, {
  "user.name": 1,
  "items.productName": 1,
  "items.category": 1,
  "items.quantity": 1,
  "items.unitPrice": 1,
  "orderDate": 1
});
 
// ドキュメント構造の例:
{
  _id: ObjectId("..."),
  userId: 12345,
  user: {               // ユーザー情報を埋め込み
    name: "田中太郎",
    email: "tanaka@example.com"
  },
  orderDate: ISODate("2026-02-01"),
  status: "shipped",
  items: [              // 商品情報を埋め込み
    {
      productId: 100,
      productName: "ノートPC",
      category: "家電",
      quantity: 1,
      unitPrice: 120000
    },
    {
      productId: 201,
      productName: "マウス",
      category: "周辺機器",
      quantity: 2,
      unitPrice: 3000
    }
  ],
  total: 126000,
  shippingAddress: {
    zip: "100-0001",
    city: "東京都千代田区"
  }
}
// 1回のクエリで全データ取得（JOIN不要）
// ただし、ユーザー名変更時に全注文ドキュメントを更新必要

-- PostgreSQL JSONB: RDBの枠内でドキュメント的な柔軟性を実現
 
-- テーブル定義（固定カラム + JSONB）
CREATE TABLE products (
    id       SERIAL PRIMARY KEY,
    name     VARCHAR(200) NOT NULL,
    category VARCHAR(50) NOT NULL,
    price    DECIMAL(10, 2) NOT NULL,
    attrs    JSONB DEFAULT '{}'  -- 可変属性
);
 
-- カテゴリごとに異なる属性を格納
INSERT INTO products (name, category, price, attrs) VALUES
('ノートPC', '家電', 120000, '{
    "brand": "Dell",
    "cpu": "Core i7",
    "ram_gb": 16,
    "storage": {"type": "SSD", "size_gb": 512},
    "ports": ["USB-C", "HDMI", "USB-A"]
}'),
('Tシャツ', 'アパレル', 3000, '{
    "brand": "Uniqlo",
    "size": "M",
    "color": "black",
    "material": "cotton"
}');
 
-- JSONB のクエリ（GINインデックスで高速）
CREATE INDEX idx_products_attrs ON products USING GIN (attrs);
 
-- 特定の属性値で検索
SELECT name, price, attrs->>'brand' AS brand
FROM products
WHERE attrs->>'cpu' = 'Core i7';
 
-- ネストした属性の検索
SELECT name, attrs->'storage'->>'type' AS storage_type
FROM products
WHERE (attrs->'storage'->>'size_gb')::int >= 256;
 
-- 配列内の値を検索
SELECT name FROM products
WHERE attrs->'ports' ? 'USB-C';
 
-- JSONB の集約
SELECT
    attrs->>'brand' AS brand,
    COUNT(*) AS product_count,
    AVG(price) AS avg_price
FROM products
GROUP BY attrs->>'brand';

# DynamoDB シングルテーブルデザインの実装
import boto3
from datetime import datetime
from decimal import Decimal
 
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('MyApp')
 
class UserRepository:
    def create_user(self, user_id, name, email):
        """ユーザー作成"""
        table.put_item(Item={
            'PK': f'USER#{user_id}',
            'SK': 'PROFILE',
            'name': name,
            'email': email,
            'created_at': datetime.utcnow().isoformat(),
            'GSI1PK': 'USER',
            'GSI1SK': email  # メールで検索可能
        })
 
    def get_user(self, user_id):
        """ユーザー情報取得"""
        response = table.get_item(
            Key={'PK': f'USER#{user_id}', 'SK': 'PROFILE'}
        )
        return response.get('Item')
 
    def get_user_with_orders(self, user_id):
        """ユーザー情報 + 注文一覧（1クエリ）"""
        response = table.query(
            KeyConditionExpression='PK = :pk',
            ExpressionAttributeValues={':pk': f'USER#{user_id}'}
        )
        items = response['Items']
        user = next((i for i in items if i['SK'] == 'PROFILE'), None)
        orders = [i for i in items if i['SK'].startswith('ORDER#')]
        return {'user': user, 'orders': orders}
 
    def find_by_email(self, email):
        """メールアドレスでユーザー検索（GSI使用）"""
        response = table.query(
            IndexName='GSI1',
            KeyConditionExpression='GSI1PK = :pk AND GSI1SK = :email',
            ExpressionAttributeValues={
                ':pk': 'USER',
                ':email': email
            }
        )
        return response['Items']
 
class OrderRepository:
    def create_order(self, user_id, order_id, items, total):
        """注文作成（トランザクション使用）"""
        client = boto3.client('dynamodb')
        transact_items = [
            # 注文をユーザーのPKの下に作成
            {
                'Put': {
                    'TableName': 'MyApp',
                    'Item': {
                        'PK': {'S': f'USER#{user_id}'},
                        'SK': {'S': f'ORDER#{datetime.utcnow().strftime("%Y-%m-%d")}#{order_id}'},
                        'order_id': {'S': order_id},
                        'total': {'N': str(total)},
                        'status': {'S': 'pending'},
                        'GSI1PK': {'S': 'ORDER'},
                        'GSI1SK': {'S': datetime.utcnow().strftime("%Y-%m-%d")}
                    }
                }
            }
        ]
        # 各商品アイテムも追加
        for i, item in enumerate(items):
            transact_items.append({
                'Put': {
                    'TableName': 'MyApp',
                    'Item': {
                        'PK': {'S': f'ORDER#{order_id}'},
                        'SK': {'S': f'ITEM#{i:03d}'},
                        'product': {'S': item['name']},
                        'quantity': {'N': str(item['quantity'])},
                        'price': {'N': str(item['price'])}
                    }
                }
            })
 
        client.transact_write_items(TransactItems=transact_items)

import redis
import json
import time
 
r = redis.Redis()
 
# === セッション管理 ===
class SessionStore:
    def create_session(self, session_id, user_data, ttl=3600):
        """セッション作成（1時間有効）"""
        r.setex(
            f"session:{session_id}",
            ttl,
            json.dumps(user_data)
        )
 
    def get_session(self, session_id):
        """セッション取得"""
        data = r.get(f"session:{session_id}")
        if data:
            r.expire(f"session:{session_id}", 3600)  # TTLリフレッシュ
            return json.loads(data)
        return None
 
    def delete_session(self, session_id):
        """セッション削除"""
        r.delete(f"session:{session_id}")
 
 
# === レート制限 ===
class RateLimiter:
    def is_allowed(self, user_id, max_requests=100, window_seconds=60):
        """固定ウィンドウレート制限"""
        key = f"rate:{user_id}:{int(time.time()) // window_seconds}"
        current = r.incr(key)
        if current == 1:
            r.expire(key, window_seconds)
        return current <= max_requests
 
    def is_allowed_sliding(self, user_id, max_requests=100, window_seconds=60):
        """スライディングウィンドウレート制限"""
        key = f"rate_sliding:{user_id}"
        now = time.time()
        pipe = r.pipeline()
        pipe.zremrangebyscore(key, 0, now - window_seconds)
        pipe.zadd(key, {str(now): now})
        pipe.zcard(key)
        pipe.expire(key, window_seconds)
        results = pipe.execute()
        return results[2] <= max_requests
 
 
# === 分散ロック ===
class DistributedLock:
    def acquire(self, lock_name, ttl=10):
        """ロック取得（Redlock簡易版）"""
        lock_key = f"lock:{lock_name}"
        token = str(time.time())
        acquired = r.set(lock_key, token, nx=True, ex=ttl)
        return token if acquired else None
 
    def release(self, lock_name, token):
        """ロック解放（Luaスクリプトでアトミックに）"""
        script = """
        if redis.call("get", KEYS[1]) == ARGV[1] then
            return redis.call("del", KEYS[1])
        else
            return 0
        end
        """
        r.eval(script, 1, f"lock:{lock_name}", token)
 
 
# === リアルタイムランキング ===
class Leaderboard:
    def update_score(self, board_name, user_id, score):
        """スコア更新"""
        r.zadd(f"leaderboard:{board_name}", {user_id: score})
 
    def get_rank(self, board_name, user_id):
        """順位取得（0-indexed）"""
        rank = r.zrevrank(f"leaderboard:{board_name}", user_id)
        return rank + 1 if rank is not None else None
 
    def get_top_n(self, board_name, n=10):
        """上位N位を取得"""
        return r.zrevrange(
            f"leaderboard:{board_name}", 0, n - 1,
            withscores=True
        )
 
    def get_around_me(self, board_name, user_id, range_size=5):
        """自分の前後N位を取得"""
        rank = r.zrevrank(f"leaderboard:{board_name}", user_id)
        if rank is None:
            return []
        start = max(0, rank - range_size)
        end = rank + range_size
        return r.zrevrange(
            f"leaderboard:{board_name}", start, end,
            withscores=True
        )

// MongoDB のドキュメントサイズ上限: 16MB
// 配列の無制限な成長はアンチパターン
 
// [NG] コメントを全て埋め込み → ドキュメント肥大化
db.posts.updateOne(
  { _id: postId },
  { $push: { comments: newComment } }
);
// → 人気投稿は数万コメントでドキュメントサイズ上限に到達
 
// [OK] バケットパターン（サブドキュメント分割）
db.post_comments.insertOne({
  postId: postId,
  bucket: Math.floor(commentCount / 100),  // 100件ごとにバケット
  comments: [newComment],
  count: 1
});
 
// [OK] 参照パターン（別コレクション）
db.comments.insertOne({
  postId: postId,
  userId: userId,
  text: "Great post!",
  createdAt: new Date()
});
// → 無制限に成長可能

# Redis メモリ管理のベストプラクティス
 
# 1. TTL の設定（全キーに推奨）
r.setex("cache:user:1", 300, user_json)  # 5分で期限切れ
 
# 2. メモリポリシーの設定
# redis.conf: maxmemory 4gb
# redis.conf: maxmemory-policy allkeys-lru
 
# 3. メモリ使用量の監視
info = r.info('memory')
print(f"使用メモリ: {info['used_memory_human']}")
print(f"ピークメモリ: {info['used_memory_peak_human']}")
print(f"フラグメンテーション比率: {info['mem_fragmentation_ratio']}")
 
# 4. 大きなキーの検出
# redis-cli --bigkeys
# redis-cli MEMORY USAGE key_name

// MongoDB NoSQL インジェクション
// [NG] ユーザー入力を直接クエリに使用
const user = await db.users.findOne({
  username: req.body.username,
  password: req.body.password  // {"$gt": ""} が渡されると全ユーザーにマッチ
});
 
// [OK] 入力の型チェック + サニタイズ
const username = String(req.body.username);
const password = String(req.body.password);
const user = await db.users.findOne({
  username: username,
  password: password  // 文字列型が保証される
});
 
// [推奨] パスワードはハッシュ化
const user = await db.users.findOne({ username: username });
if (user && await bcrypt.compare(password, user.passwordHash)) {
  // 認証成功
}

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

// スロークエリの調査
db.setProfilingLevel(1, { slowms: 100 });  // 100ms以上のクエリを記録
db.system.profile.find().sort({ ts: -1 }).limit(5);
 
// 実行計画の確認
db.orders.find({ userId: "001" }).explain("executionStats");
// COLLSCAN → インデックスが使われていない
 
// インデックスの作成
db.orders.createIndex({ userId: 1, createdAt: -1 });

# 接続プーリングの設定
pool = redis.ConnectionPool(
    host='localhost',
    port=6379,
    max_connections=50,  # 接続プールサイズ
    socket_timeout=5,
    socket_connect_timeout=5,
    retry_on_timeout=True
)
r = redis.Redis(connection_pool=pool)

# 指数バックオフ付きリトライ
import time
from botocore.exceptions import ClientError
 
def put_with_retry(item, max_retries=5):
    for attempt in range(max_retries):
        try:
            table.put_item(Item=item)
            return
        except ClientError as e:
            if e.response['Error']['Code'] == 'ProvisionedThroughputExceededException':
                wait_time = (2 ** attempt) * 0.1  # 0.1, 0.2, 0.4, 0.8, 1.6秒
                time.sleep(wait_time)
            else:
                raise
    raise Exception("Max retries exceeded")