Guia de desempenho

# pandas: Carrega TODOS os dados e depois filtra na memória
df = pd.read_csv("huge.csv")       # Carrega 10GB
df = df[df['year'] == 2024]        # Filtra em Python

# DataStore: Filtra na origem
ds = pd.read_csv("huge.csv")       # Apenas metadados
ds = ds[ds['year'] == 2024]        # Filtra em SQL
df = ds.to_df()                    # Carrega apenas os dados filtrados

# DataStore: Lê apenas as colunas name, age
ds = pd.read_parquet("wide_table.parquet")
result = ds.select('name', 'age').to_df()

# vs pandas: Lê todas as 100 colunas, depois seleciona

# DataStore: Uma consulta SQL otimizada
result = (ds
    .filter(ds['amount'] > 100)
    .groupby('region')
    .agg({'amount': 'sum'})
    .sort('sum', ascending=False)
    .head(10)
    .to_df()
)

# Resulta em:
# SELECT region, SUM(amount) FROM data
# WHERE amount > 100
# GROUP BY region ORDER BY sum DESC LIMIT 10

# DataStore se destaca: 19.93x mais rápido
result = ds.groupby('category')['amount'].sum()

# DataStore se destaca: 5 a 6x mais rápido
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: Carrega apenas o que você precisa
ds = pd.read_parquet("huge_file.parquet")
result = ds.filter(ds['id'] == 12345).to_df()  # Rápido!

# DataStore: Combina em um único SQL
ds['total'] = ds['price'] * ds['quantity']
ds['is_large'] = ds['total'] > 1000
ds = ds.filter(ds['is_large'])

# Para conjuntos de dados muito pequenos, a sobrecarga é mínima em ambos os casos
# A diferença de desempenho é desprezível
small_df = pd.DataFrame({'x': range(100)})

# Operações de fatiamento simples sem agregação
df = df[df['x'] > 10]  # pandas ligeiramente mais rápido
ds = ds[ds['x'] > 10]  # DataStore comparável

# pandas necessário para código Python personalizado
def complex_function(row):
    return custom_logic(row)

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

# to_df() NÃO copia dados - é uma operação zero-copy
result = ds.filter(ds['x'] > 10).to_df()  # Sem sobrecarga de conversão de dados

# O mesmo se aplica ao criar um DataStore a partir de um DataFrame
ds = DataStore(existing_df)  # Sem cópia de dados

from chdb.datastore.config import config

config.use_performance_mode()

# Agora todas as operações usam execução SQL-first sem overhead do pandas:
# - Leitura paralela de Parquet (sem preserve_order)
# - Agregação em SQL único (filter+groupby em uma única consulta)
# - Sem overhead de preservação de ordem de linhas
# - Sem MultiIndex, sem correções de dtype
result = (ds
    .filter(ds['amount'] > 100)
    .groupby('region')
    .agg({'amount': ['sum', 'mean', 'count']})
)

# CSV: Mais lento, lê o arquivo inteiro
ds = pd.read_csv("data.csv")

# Parquet: Mais rápido, colunar, comprimido
ds = pd.read_parquet("data.parquet")

# Converta uma vez, aproveite para sempre
df = pd.read_csv("data.csv")
df.to_parquet("data.parquet")

# Bom: Filtre primeiro, depois agregue
result = (ds
    .filter(ds['date'] >= '2024-01-01')  # Reduza os dados antecipadamente
    .groupby('category')['amount'].sum()
)

# Menos otimizado: Processa todos os dados
result = (ds
    .groupby('category')['amount'].sum()
    .filter(ds['sum'] > 1000)  # Filtra tarde demais
)

# Bom: poda de colunas
result = ds.select('name', 'amount').filter(ds['amount'] > 100)

# Menos otimizado: Todas as colunas carregadas
result = ds.filter(ds['amount'] > 100)  # Carrega todas as colunas

# GroupBy é onde o DataStore se destaca
# Até 20x mais rápido!
result = ds.groupby('category').agg({
    'amount': ['sum', 'mean', 'count', 'max'],
    'quantity': 'sum'
})

# Não carregue o resultado inteiro se você só precisa de uma amostra
result = ds.filter(ds['type'] == 'A').head(100)  # LIMIT 100

# Evite isso para resultados grandes
# result = ds.filter(ds['type'] == 'A').to_df()  # Carrega tudo

# Correto: execução única
result = ds.filter(ds['x'] > 10).filter(ds['y'] < 100).to_df()

# Incorreto: múltiplas execuções
result1 = ds.filter(ds['x'] > 10).to_df()  # Executa
result2 = result1[result1['y'] < 100]       # Executa novamente

# Visualize o plano de consulta antes de executar
query = ds.filter(...).groupby(...).agg(...)
query.explain()  # Verifique se as operações são delegadas à origem (pushdown)

# Em seguida, execute
result = query.to_df()

from chdb.datastore.config import config, get_profiler

config.enable_profiling()

# Execute seu workload
result = your_pipeline()

# Visualizar relatório
profiler = get_profiler()
profiler.report()

Relatório de desempenho
=======================
Etapa                   Duração     % Total
----                    --------    -------
Execução de SQL         2.5s        62.5%     <- Gargalo!
read_csv                1.2s        30.0%
Outros                  0.3s        7.5%

# Testar abordagem 1
profiler.reset()
result1 = approach1()
time1 = profiler.get_steps()[-1]['duration_ms']

# Testar abordagem 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")