Shopify 用广度优先引擎把 GraphQL 执行速度拉到 15 倍

query {
  shop { products(first: 100) { edges { node {
    variants(first: 10) { edges { node {
      inventory { locations(first: 5) { edges { node { name } } } }
      pricing { compareAtPrice }
    } } }
    images(first: 3) { edges { node { url } } }
  } } } } }
}

"""
深度优先 vs 广度优先 GraphQL 执行顺序对比
运行: python3 execution_order_demo.py
"""

import asyncio
import time

# ---- 模拟数据 ----
PRODUCTS = [{"id": i, "name": f"Product-{i}"} for i in range(5)]
VARIANTS = {p["id"]: [{"id": j, "sku": f"SKU-{p['id']}-{j}"} for j in range(3)] for p in PRODUCTS}
INVENTORY = {v["id"]: {"stock": 100 + v["id"]} for p in PRODUCTS for v in VARIANTS[p["id"]]}

# ---- Resolver 函数 ----
async def resolve_products():
    print("  → [resolver] fetch all products (batch)")
    await asyncio.sleep(0.01)
    return PRODUCTS

async def resolve_variants(product_id):
    print(f"  → [resolver] fetch variants for product {product_id}")
    await asyncio.sleep(0.01)
    return VARIANTS[product_id]

async def resolve_inventory(variant_id):
    print(f"  → [resolver] fetch inventory for variant {variant_id}")
    await asyncio.sleep(0.01)
    return INVENTORY[variant_id]

# ---- 深度优先执行 ----
async def depth_first():
    print("\n=== 深度优先执行 ===")
    products = await resolve_products()
    for p in products:
        variants = await resolve_variants(p["id"])
        for v in variants:
            inv = await resolve_inventory(v["id"])

# ---- 广度优先执行（模拟 Cardinal） ----
async def breadth_first():
    print("\n=== 广度优先执行 (Cardinal 风格) ===")
    # 第 1 层: products
    products = await resolve_products()

    # 第 2 层: 所有产品的 variants，批量并发
    variant_tasks = [resolve_variants(p["id"]) for p in products]
    all_variants = await asyncio.gather(*variant_tasks)

    # 第 3 层: 所有变体的 inventory，批量并发
    all_variant_ids = [v["id"] for variants in all_variants for v in variants]
    inv_tasks = [resolve_inventory(vid) for vid in all_variant_ids]
    await asyncio.gather(*inv_tasks)

# ---- 运行对比 ----
async def main():
    t1 = time.perf_counter()
    await depth_first()
    t2 = time.perf_counter()
    print(f"深度优先耗时: {t2 - t1:.4f}s")

    t3 = time.perf_counter()
    await breadth_first()
    t4 = time.perf_counter()
    print(f"广度优先耗时: {t4 - t3:.4f}s")

asyncio.run(main())

=== 深度优先执行 ===
  → [resolver] fetch all products (batch)
  → [resolver] fetch variants for product 0
  → [resolver] fetch inventory for variant 0
  → [resolver] fetch inventory for variant 1
  → [resolver] fetch inventory for variant 2
  → [resolver] fetch variants for product 1
  → [resolver] fetch inventory for variant 3
  ...
深度优先耗时: 0.0800s

=== 广度优先执行 (Cardinal 风格) ===
  → [resolver] fetch all products (batch)
  → [resolver] fetch variants for product 0
  → [resolver] fetch variants for product 1
  → [resolver] fetch variants for product 2
  → [resolver] fetch variants for product 3
  → [resolver] fetch variants for product 4
  → [resolver] fetch inventory for variant 0
  → [resolver] fetch inventory for variant 1
  → [resolver] fetch inventory for variant 2
  → [resolver] fetch inventory for variant 3
  ...
广度优先耗时: 0.0300s

// Node.js 示例：用 DataLoader 把同请求内的 resolver 合并
const DataLoader = require('dataloader');

const variantLoader = new DataLoader(async (productIds) => {
  // 一次查询拿到所有产品的 variants，而不是 N 次单独查询
  const results = await db.query(
    'SELECT * FROM variants WHERE product_id = ANY($1)',
    [productIds]
  );
  return productIds.map(id => results.filter(r => r.product_id === id));
});

// 在 resolver 中使用
const resolvers = {
  Product: {
    variants: (product) => variantLoader.load(product.id),
  },
};

// 极简示意：按层级收集字段，批量执行
async function breadthFirstExecute(schema, document, rootValue) {
  const layers = collectFieldLayers(schema, document); // 按深度分层
  let currentValue = rootValue;

  for (const layer of layers) {
    // 同一层所有字段的 resolver 并发执行
    const fieldEntries = Object.entries(layer);
    const results = await Promise.all(
      fieldEntries.map(([fieldName, fieldDef]) =>
        fieldDef.resolve(currentValue)
      )
    );
    // 组装结果供下一层使用
    currentValue = Object.fromEntries(
      fieldEntries.map(([fieldName], i) => [fieldName, results[i]])
    );
  }
  return currentValue;
}