성능 가이드

# 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()는 데이터를 복사하지 않습니다. 즉, zero-copy 작업입니다
result = ds.filter(ds['x'] > 10).to_df()  # 데이터 변환 오버헤드 없음

# DataFrame에서 DataStore를 생성할 때도 마찬가지입니다
ds = DataStore(existing_df)  # 데이터 복사 없음

from chdb.datastore.config import config

config.use_performance_mode()

# 이제 모든 연산이 pandas 오버헤드 없이 SQL 우선 실행으로 처리됩니다:
# - 병렬 Parquet 읽기 (preserve_order 없음)
# - 단일 SQL 집계 (filter+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 execution           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")