performance

性能优化 - 关键最佳实践

绝不要获取完整数据集

关键规则： 绝不要获取整个数据集，尤其是大型数据集（10 万行以上）。始终使用有针对性的查询，只包含每个可视化所需的列。

性能影响

// ❌ TERRIBLE - Fetches 300k rows × 30 columns = 9M data points
const allData = await new Query()
  .select(['col1', 'col2', 'col3', ...]) // All columns
  .fetch('dataset');

// ✅ GOOD - Fetches 300k rows × 2 columns = 600k data points (93% reduction)
const totals = await new Query()
  .select(['Transactions', 'Total Amount (USD)'])
  .fetch('dataset');
// Then aggregate client-side

// ✅ BEST - Server-side aggregation, returns only aggregated results
const totals = await new Query()
  .groupBy('Merchant Category', { 'Total Amount (USD)': 'sum' })
  .fetch('dataset');
// Returns only ~10-20 rows (one per category)

查询优化策略

1. 尽可能使用服务端聚合

优先级顺序：

1. 最佳： 使用带聚合的 .groupBy()（服务端）
2. 良好： 使用 .select() 只选择需要的列，然后在客户端聚合
3. 可接受： 如果无法聚合，使用 .select() 选择多列
4. 绝不： 获取所有列或整个数据集

// ✅ BEST - Server aggregates, returns minimal data
const salesByRegion = await new Query()
  .groupBy('region', { 'Sales_Amount': 'sum', 'Order_Count': 'count' })
  .fetch('sales');

// ✅ GOOD - Only fetch columns needed, aggregate client-side
const salesData = await new Query()
  .select(['region', 'Sales_Amount'])
  .fetch('sales');
const totalSales = salesData.reduce((sum, row) => sum + row.Sales_Amount, 0);

// ❌ BAD - Fetches all columns
const allData = await new Query().fetch('sales');

2. 每个可视化一个查询

每个可视化都应有自己的优化查询：

// ✅ CORRECT - Separate optimized queries
const quickStats = await fetchQuickStats();      // Only Account Key, Account Status
const riskMetrics = await fetchRiskMetrics();    // Only Transactions, KYC Status, etc.
const categories = await fetchCategories();      // Grouped by Merchant Category

// ❌ WRONG - One query for everything
const allData = await fetchAllData();
const quickStats = calculateFromAll(allData);
const riskMetrics = calculateFromAll(allData);
const categories = calculateFromAll(allData);

3. 列选择策略

始终明确指定列：

• 只选择特定计算所需的列
• 不要使用不带参数的 .select()（会获取所有列）
• 对于聚合，只选择分组列 + 聚合列

// ✅ CORRECT - Only 2 columns
const data = await new Query()
  .select(['Account Key', 'Account Status'])
  .fetch('dataset');

// ❌ WRONG - Fetches all columns
const data = await new Query().fetch('dataset');

常见模式

模式 1：不带分组的汇总

当你需要汇总值但没有分组列时：

// Option A: Select only needed columns, sum client-side
const totalsData = await new Query()
  .select(['Transactions', 'Total Amount (USD)'])
  .fetch('dataset');
const totalTransactions = totalsData.reduce((sum, row) => sum + (row.Transactions || 0), 0);
const totalVolume = totalsData.reduce((sum, row) => sum + (row['Total Amount (USD)'] || 0), 0);

// Option B: Use a constant grouping column (if dataset has one)
// Not always possible, but more efficient if available

模式 2：带筛选条件的计数

// ✅ CORRECT - Only fetch the column needed for counting
const kycData = await new Query()
  .select(['KYC Status'])
  .fetch('dataset');
const approvedCount = kycData.filter(row => row['KYC Status'] === 'APPROVED').length;

// Better if possible: Use server-side count aggregation
// (See Query API limitations below)

模式 3：唯一值

// ✅ CORRECT - Only fetch the column needed
const statesData = await new Query()
  .select(['State'])
  .fetch('dataset');
const uniqueStates = new Set(statesData.map(row => row.State)).size;

查询 API 限制

.aggregate() 不起作用

关键： 某些文档中展示的 .aggregate() 方法在实践中不起作用。它会导致错误：DA0057: An alias list was provided but it could not be parsed。

// ❌ DOES NOT WORK - Causes DA0057 error
const totals = await new Query()
  .aggregate({ 'Transactions': 'sum', 'Total Amount (USD)': 'sum' })
  .fetch('dataset');

// ✅ WORKAROUND - Use .groupBy() with a grouping column
const totals = await new Query()
  .groupBy('some_column', { 'Transactions': 'sum', 'Total Amount (USD)': 'sum' })
  .fetch('dataset');

// ✅ ALTERNATIVE - Select columns and aggregate client-side
const totals = await new Query()
  .select(['Transactions', 'Total Amount (USD)'])
  .fetch('dataset');
// Then sum client-side

.groupBy() 需要分组列

你不能只使用聚合来调用 .groupBy()——必须提供一个分组列：

// ❌ DOES NOT WORK - No grouping column
.groupBy({ 'Transactions': 'sum' })

// ✅ WORKS - Has grouping column
.groupBy('region', { 'Transactions': 'sum' })

// ✅ WORKS - Multiple groupBy calls
.groupBy('region')
.groupBy({ 'Transactions': 'sum' })

性能监控

始终检查：

1. 网络标签页 - 传输了多少数据？
2. 控制台 - 是否有关于大型查询的警告？
3. 响应时间 - 查询是否耗时过长？

如果某个查询很慢或返回过多数据：

• 减少选择的列
• 添加筛选条件以减少行数
• 使用服务端聚合而不是客户端聚合
• 考虑对大型结果集进行分页