性能指南

# pandas：加载所有数据，然后在内存中过滤
df = pd.read_csv("huge.csv")       # 加载 10GB
df = df[df['year'] == 2024]        # 在 Python 中过滤

# DataStore：在数据源处过滤
ds = pd.read_csv("huge.csv")       # 仅获取元数据
ds = ds[ds['year'] == 2024]        # 在 SQL 中过滤
df = ds.to_df()                    # 仅加载过滤后的数据

# DataStore：仅读取 name 和 age 列
ds = pd.read_parquet("wide_table.parquet")
result = ds.select('name', 'age').to_df()

# 相比 pandas：会先读取全部 100 列，再进行选择

# DataStore：一条优化后的 SQL 查询
result = (ds
    .filter(ds['amount'] > 100)
    .groupby('region')
    .agg({'amount': 'sum'})
    .sort('sum', ascending=False)
    .head(10)
    .to_df()
)

# 转换为：
# SELECT region, SUM(amount) FROM data
# WHERE amount > 100
# GROUP BY region ORDER BY sum DESC LIMIT 10

# DataStore 表现出色：速度提升 19.93 倍
result = ds.groupby('category')['amount'].sum()

# DataStore 表现卓越：速度提升 5-6 倍
result = (ds
    .filter(ds['date'] >= '2024-01-01')
    .filter(ds['amount'] > 100)
    .groupby('region')
    .agg({'amount': ['sum', 'mean', 'count']})
    .sort('sum', ascending=False)
    .head(20)
)

# DataStore：仅加载所需数据
ds = pd.read_parquet("huge_file.parquet")
result = ds.filter(ds['id'] == 12345).to_df()  # 快速！

# DataStore：合并为单个 SQL
ds['total'] = ds['price'] * ds['quantity']
ds['is_large'] = ds['total'] > 1000
ds = ds.filter(ds['is_large'])

# 对于非常小的数据集，两者的开销都微乎其微
# 性能差异可忽略不计
small_df = pd.DataFrame({'x': range(100)})

# 不含聚合的单次切片操作
df = df[df['x'] > 10]  # pandas 略快
ds = ds[ds['x'] > 10]  # DataStore 性能相当

# 自定义 Python 代码需要 pandas
def complex_function(row):
    return custom_logic(row)

df['result'] = df.apply(complex_function, axis=1)

# to_df() 不会复制数据——这是一个零拷贝操作
result = ds.filter(ds['x'] > 10).to_df()  # 无数据转换开销

# 从 DataFrame 创建 DataStore 同理
ds = DataStore(existing_df)  # 无数据复制

from chdb.datastore.config import config

config.use_performance_mode()

# 现在所有操作均采用 SQL 优先执行，无 pandas 额外开销：
# - 并行 Parquet 读取（无 preserve_order）
# - 单条 SQL 聚合（过滤器+groupby 合并为一个查询）
# - 无行序保留开销
# - 无 MultiIndex，无 dtype 修正
result = (ds
    .filter(ds['amount'] > 100)
    .groupby('region')
    .agg({'amount': ['sum', 'mean', 'count']})
)

# CSV：较慢，读取整个文件
ds = pd.read_csv("data.csv")

# Parquet：更快，列式存储，已压缩
ds = pd.read_parquet("data.parquet")

# 一次转换，长期受益
df = pd.read_csv("data.csv")
df.to_parquet("data.parquet")

# 好的做法：先过滤，再聚合
result = (ds
    .filter(ds['date'] >= '2024-01-01')  # 尽早缩减数据量
    .groupby('category')['amount'].sum()
)

# 次优做法：处理全量数据
result = (ds
    .groupby('category')['amount'].sum()
    .filter(ds['sum'] > 1000)  # 过滤时机太晚
)

# 良好：列裁剪
result = ds.select('name', 'amount').filter(ds['amount'] > 100)

# 次优：加载所有列
result = ds.filter(ds['amount'] > 100)  # 加载所有列

# GroupBy 正是 DataStore 的强项所在
# 最高可提速 20 倍！
result = ds.groupby('category').agg({
    'amount': ['sum', 'mean', 'count', 'max'],
    'quantity': 'sum'
})

# 如果只需要样本，不要加载整个结果
result = ds.filter(ds['type'] == 'A').head(100)  # LIMIT 100

# 对于大型结果集，避免使用此方式
# result = ds.filter(ds['type'] == 'A').to_df()  # 加载所有数据

# 好的做法：单次执行
result = ds.filter(ds['x'] > 10).filter(ds['y'] < 100).to_df()

# 不好的做法：多次执行
result1 = ds.filter(ds['x'] > 10).to_df()  # 执行
result2 = result1[result1['y'] < 100]       # 再次执行

# 在执行前查看查询计划
query = ds.filter(...).groupby(...).agg(...)
query.explain()  # 检查操作是否已下推

# 然后执行
result = query.to_df()

from chdb.datastore.config import config, get_profiler

config.enable_profiling()

# 运行您的工作负载
result = your_pipeline()

# 查看报告
profiler = get_profiler()
profiler.report()

性能报告
==================
步骤                    耗时        总占比
----                    --------    -------
SQL 执行                2.5s        62.5%     <- 瓶颈！
read_csv                1.2s        30.0%
其他                    0.3s        7.5%

# 测试方法 1
profiler.reset()
result1 = approach1()
time1 = profiler.get_steps()[-1]['duration_ms']

# 测试方法 2
profiler.reset()
result2 = approach2()
time2 = profiler.get_steps()[-1]['duration_ms']

print(f"Approach 1: {time1:.0f}ms")
print(f"Approach 2: {time2:.0f}ms")