Guía de rendimiento

Consejos para optimizar el rendimiento de DataStore frente a pandas

DataStore ofrece mejoras significativas de rendimiento frente a pandas en muchas operaciones. Esta guía explica por qué y cómo optimizar sus cargas de trabajo.

​

Por qué DataStore es más rápido

​

1. SQL Pushdown

Las operaciones se ejecutan en la fuente de datos:

# pandas: Carga TODOS los datos y luego filtra en memoria
df = pd.read_csv("huge.csv")       # Carga 10 GB
df = df[df['year'] == 2024]        # Filtra en Python

# DataStore: Filtra en el origen
ds = pd.read_csv("huge.csv")       # Solo metadatos
ds = ds[ds['year'] == 2024]        # Filtra en SQL
df = ds.to_df()                    # Solo carga los datos filtrados

​

2. Poda de columnas

Solo se leen las columnas necesarias:

# DataStore: Solo lee las columnas name, age
ds = pd.read_parquet("wide_table.parquet")
result = ds.select('name', 'age').to_df()

# vs pandas: Lee las 100 columnas y luego selecciona

​

3. Evaluación diferida

Varias operaciones se traducen a una sola consulta:

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

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

---

​

Benchmark: DataStore vs pandas

​

Entorno de prueba

• Datos: 10 millones de filas
• Hardware: portátil estándar
• Formato de archivo: CSV

​

Resultados

Operación	pandas (ms)	DataStore (ms)	Ganador
Conteo con GroupBy	347	17	DataStore (19.93x)
Operaciones combinadas	1,535	234	DataStore (6.56x)
Canalización compleja	2,047	380	DataStore (5.39x)
MultiFilter+Sort+Head	1,963	366	DataStore (5.36x)
Filter+Sort+Head	1,537	350	DataStore (4.40x)
Head/Limit	166	45	DataStore (3.69x)
Ultra complejo (10+ ops)	1,070	338	DataStore (3.17x)
Agregación con GroupBy	406	141	DataStore (2.88x)
Select+Filter+Sort	1,217	443	DataStore (2.75x)
Filter+GroupBy+Sort	466	184	DataStore (2.53x)
Filter+Select+Sort	1,285	533	DataStore (2.41x)
Sort (simple)	1,742	1,197	DataStore (1.45x)
Filter (simple)	276	526	Comparable
Sort (múltiple)	947	1,477	Comparable

​

Puntos clave

1. Operaciones de GroupBy: DataStore es hasta 19.93x más rápido
2. Canalizaciones complejas: DataStore es 5-6x más rápido (gracias al pushdown en SQL)
3. Operaciones de slicing simples: rendimiento comparable; diferencia insignificante
4. Caso de uso ideal: operaciones de varios pasos con groupby/agregación
5. Zero-copy: to_df() no tiene sobrecarga por conversión de datos

---

​

Cuándo conviene usar DataStore

​

Agregaciones exigentes

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

​

Canalizaciones complejas

# DataStore sobresale: 5-6x más 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)
)

​

Procesamiento de archivos de gran tamaño

# DataStore: Solo carga lo que necesitas
ds = pd.read_parquet("huge_file.parquet")
result = ds.filter(ds['id'] == 12345).to_df()  # ¡Rápido!

​

Operaciones con varias columnas

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

---

​

Cuándo pandas ofrece un rendimiento comparable

En la mayoría de los casos, DataStore iguala o supera el rendimiento de pandas. Sin embargo, pandas puede ser ligeramente más rápido en estos casos concretos:

​

Conjuntos de datos pequeños (<1,000 filas)

# Para conjuntos de datos muy pequeños, la sobrecarga es mínima en ambos casos
# La diferencia de rendimiento es insignificante
small_df = pd.DataFrame({'x': range(100)})

​

Operaciones simples de slicing

# Operaciones de segmentación simples sin agregación
df = df[df['x'] > 10]  # pandas es algo más rápido
ds = ds[ds['x'] > 10]  # DataStore ofrece un rendimiento comparable

​

Funciones lambda personalizadas de Python

# se requiere pandas para código Python personalizado
def complex_function(row):
    return custom_logic(row)

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

Importante

Incluso en los casos en que DataStore es “más lento”, el rendimiento suele estar a la altura de pandas; la diferencia es insignificante en la práctica. Las ventajas de DataStore en operaciones complejas superan con creces estos casos puntuales.

Para un control más preciso de la ejecución, consulte Configuración de Execution Engine.

---

​

Integración zero-copy de DataFrames

DataStore usa zero-copy para leer y escribir DataFrames de pandas. Esto significa:

# to_df() NO copia datos - es una operación zero-copy
result = ds.filter(ds['x'] > 10).to_df()  # Sin sobrecarga de conversión de datos

# Lo mismo aplica para crear un DataStore desde un DataFrame
ds = DataStore(existing_df)  # Sin copia de datos

Implicaciones clave:

• to_df() es prácticamente gratuito: no hay serialización ni copias de memoria
• Crear un DataStore a partir de un DataFrame de pandas es instantáneo
• La memoria se comparte entre DataStore y las vistas de pandas

---

​

Consejos de optimización

​

1. Activa el modo de rendimiento para cargas de trabajo intensivas

Para cargas de trabajo con agregación intensiva en las que no necesitas el formato de salida exacto de pandas (orden de las filas, columnas MultiIndex, correcciones de dtype), activa el modo de rendimiento para maximizar el throughput:

from chdb.datastore.config import config

config.use_performance_mode()

# Ahora todas las operaciones usan ejecución SQL-first sin sobrecarga de pandas:
# - Lectura paralela de Parquet (sin preserve_order)
# - Agregación en una sola consulta SQL (filter+groupby en una sola consulta)
# - Sin sobrecarga por preservación del orden de filas
# - Sin MultiIndex, sin correcciones de dtype
result = (ds
    .filter(ds['amount'] > 100)
    .groupby('region')
    .agg({'amount': ['sum', 'mean', 'count']})
)

Mejora esperada: Entre 2 y 8 veces más rápido en cargas de trabajo con filter+groupby, y menor uso de memoria con archivos Parquet grandes.

Consulta Modo de rendimiento para obtener todos los detalles.

​

2. Usa Parquet en lugar de CSV

# CSV: Más lento, lee el archivo completo
ds = pd.read_csv("data.csv")

# Parquet: Más rápido, columnar, comprimido
ds = pd.read_parquet("data.parquet")

# Convierte una vez, benefíciate para siempre
df = pd.read_csv("data.csv")
df.to_parquet("data.parquet")

Mejora esperada: lecturas entre 3 y 10 veces más rápidas

​

3. Filtra desde el principio

# Correcto: Filtrar primero, luego agregar
result = (ds
    .filter(ds['date'] >= '2024-01-01')  # Reducir datos con anticipación
    .groupby('category')['amount'].sum()
)

# Menos óptimo: Procesar todos los datos
result = (ds
    .groupby('category')['amount'].sum()
    .filter(ds['sum'] > 1000)  # Filtrar demasiado tarde
)

​

4. Seleccione solo las columnas necesarias

# Bueno: Poda de columnas
result = ds.select('name', 'amount').filter(ds['amount'] > 100)

# Menos óptimo: Todas las columnas cargadas
result = ds.filter(ds['amount'] > 100)  # Carga todas las columnas

​

5. Aprovecha las agregaciones en SQL

# GroupBy es donde DataStore brilla
# ¡Hasta 20x más rápido!
result = ds.groupby('category').agg({
    'amount': ['sum', 'mean', 'count', 'max'],
    'quantity': 'sum'
})

​

6. Usa head() en lugar de consultas completas

# No cargues el resultado completo si solo necesitas una muestra
result = ds.filter(ds['type'] == 'A').head(100)  # LIMIT 100

# Evita esto para resultados grandes
# result = ds.filter(ds['type'] == 'A').to_df()  # Carga todo

​

7. Operaciones por lotes

# Correcto: Ejecución única
result = ds.filter(ds['x'] > 10).filter(ds['y'] < 100).to_df()

# Incorrecto: Múltiples ejecuciones
result1 = ds.filter(ds['x'] > 10).to_df()  # Ejecutar
result2 = result1[result1['y'] < 100]       # Ejecutar de nuevo

​

8. Utiliza explain() para optimizar

# Ver el plan de consulta antes de ejecutar
query = ds.filter(...).groupby(...).agg(...)
query.explain()  # Comprobar si las operaciones se delegan al origen

# Luego ejecutar
result = query.to_df()

---

​

Perfilado de la carga de trabajo

​

Activar el perfilado

from chdb.datastore.config import config, get_profiler

config.enable_profiling()

# Ejecuta tu workload
result = your_pipeline()

# Ver informe
profiler = get_profiler()
profiler.report()

​

Identificar cuellos de botella

Informe de rendimiento
==================
Paso                    Duración    % Total
----                    --------    -------
SQL execution           2.5s        62.5%     <- ¡Cuello de botella!
read_csv                1.2s        30.0%
Otros                   0.3s        7.5%

​

Comparación de enfoques

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

# Probar enfoque 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")

---

​

Resumen de buenas prácticas

Práctica	Impacto
Active el modo de rendimiento	2-8x más rápido para cargas de trabajo de agregación
Use archivos Parquet	lecturas 3-10x más rápidas
Filtre pronto	Reduzca el procesamiento de datos
Seleccione las columnas necesarias	Reduzca la E/S y el uso de memoria
Use GroupBy/agregaciones	Hasta 20x más rápido
Agrupe operaciones en lotes	Evite la ejecución repetida
Genere un perfil antes de optimizar	Encuentre los cuellos de botella reales
Use explain()	Verifique la optimización de la consulta
Use head() para muestras	Evite escaneos completos de tablas

---

​

Guía rápida de decisión

Su carga de trabajo	Recomendación
GroupBy/agregación	Use DataStore
Canalización compleja de varios pasos	Use DataStore
Archivos grandes con filtros	Use DataStore
Operaciones de slicing simples	Cualquiera de los dos (rendimiento comparable)
Funciones lambda personalizadas de Python	Use pandas o convierta más tarde
Datos muy pequeños (<1,000 filas)	Cualquiera de los dos (diferencia insignificante)

Para seleccionar automáticamente el motor óptimo, use config.set_execution_engine('auto') (predeterminado). Para obtener el máximo rendimiento en cargas de trabajo de agregación, use config.use_performance_mode(). Consulte Execution Engine y Performance Mode para obtener más detalles.