Referencia de la clase DataStore - ClickHouse Documentation

Esta referencia documenta las clases principales de la API de DataStore.

DataStore

La clase principal, similar a un DataFrame, para manipular datos.

from chdb.datastore import DataStore

Constructor

DataStore(data=None, columns=None, index=None, dtype=None, copy=None)

Parámetros:

Parámetro	Tipo	Descripción
`data`	dict/list/DataFrame/DataStore	Datos de entrada
`columns`	list	Nombres de columnas
`index`	Index	Índice de fila
`dtype`	dict	Tipos de datos de columna
`copy`	bool	Copiar datos

Ejemplos:

# Desde un diccionario
ds = DataStore({'a': [1, 2, 3], 'b': ['x', 'y', 'z']})

# Desde un DataFrame de pandas
import pandas as pd
ds = DataStore(pd.DataFrame({'a': [1, 2, 3]}))

# DataStore vacío
ds = DataStore()

Propiedades

Propiedad	Tipo	Descripción
`columns`	Index	Nombres de columnas
`dtypes`	Series	Tipos de datos de las columnas
`shape`	tuple	(filas, columnas)
`size`	int	Total de elementos
`ndim`	int	Número de dimensiones (2)
`empty`	bool	Si el DataFrame está vacío
`values`	ndarray	Datos subyacentes como array de NumPy
`index`	Index	Índice de filas
`T`	DataStore	Transposición
`axes`	list	Lista de ejes

Métodos de fábrica

Método	Descripción
`uri(uri)`	Factoría universal a partir de un URI
`from_file(path, ...)`	Crear a partir de un archivo
`from_df(df)`	Crear a partir de un DataFrame de pandas
`from_s3(url, ...)`	Crear a partir de S3
`from_gcs(url, ...)`	Crear a partir de Google Cloud Storage
`from_azure(url, ...)`	Crear a partir de Azure Blob
`from_mysql(...)`	Crear a partir de MySQL
`from_postgresql(...)`	Crear a partir de PostgreSQL
`from_clickhouse(...)`	Crear a partir de ClickHouse
`from_mongodb(...)`	Crear a partir de MongoDB
`from_sqlite(...)`	Crear a partir de SQLite
`from_iceberg(path)`	Crear a partir de una tabla Iceberg
`from_delta(path)`	Crear a partir de Delta Lake
`from_numbers(n)`	Crear con números secuenciales
`from_random(rows, cols)`	Crear con datos aleatorios
`run_sql(query)`	Crear a partir de una consulta SQL

Consulta Métodos de fábrica para más detalles.

Métodos de consulta

Método	Devuelve	Descripción
`select(*cols)`	DataStore	Seleccionar columnas
`filter(condition)`	DataStore	Filtrar filas
`where(condition)`	DataStore	Alias de filter
`sort(*cols, ascending=True)`	DataStore	Ordenar filas
`orderby(*cols)`	DataStore	Alias de sort
`limit(n)`	DataStore	Limitar filas
`offset(n)`	DataStore	Saltar filas
`distinct(subset=None)`	DataStore	Eliminar duplicados
`groupby(*cols)`	LazyGroupBy	Agrupar filas
`having(condition)`	DataStore	Filtrar grupos
`join(right, ...)`	DataStore	Unir DataStores
`union(other, all=False)`	DataStore	Combinar DataStores
`when(cond, val)`	CaseWhen	CASE WHEN

Consulta Construcción de consultas para obtener más información.

Métodos compatibles con Pandas

Consulta Compatibilidad con Pandas para ver la lista completa de 209 métodos. Indexación: head(), tail(), sample(), loc, iloc, at, iat, query(), isin(), where(), mask(), get(), xs(), pop() Agregación: sum(), mean(), std(), var(), min(), max(), median(), count(), nunique(), quantile(), describe(), corr(), cov(), skew(), kurt() Manipulación: drop(), drop_duplicates(), dropna(), fillna(), replace(), rename(), assign(), astype(), copy() Ordenación: sort_values(), sort_index(), nlargest(), nsmallest(), rank() Reestructuración: pivot(), pivot_table(), melt(), stack(), unstack(), transpose(), explode(), squeeze() Combinación: merge(), join(), concat(), append(), combine(), update(), compare() Aplicación/transformación: apply(), applymap(), map(), agg(), transform(), pipe(), groupby() Series temporales: rolling(), expanding(), ewm(), shift(), diff(), pct_change(), resample()

Métodos de E/S

Método	Descripción
`to_csv(path, ...)`	Exportar a CSV
`to_parquet(path, ...)`	Exportar a Parquet
`to_json(path, ...)`	Exportar a JSON
`to_excel(path, ...)`	Exportar a Excel
`to_df()`	Convertir a un DataFrame de pandas
`to_pandas()`	Alias de to_df
`to_arrow()`	Convertir a una tabla de Arrow
`to_dict(orient)`	Convertir a diccionario
`to_records()`	Convertir a registros
`to_numpy()`	Convertir a un array de NumPy
`to_sql()`	Generar una cadena SQL
`to_string()`	Representación como cadena
`to_markdown()`	Tabla Markdown
`to_html()`	Tabla HTML

Consulte Operaciones de E/S para obtener más detalles.

Métodos de depuración

Método	Descripción
`explain(verbose=False)`	Muestra el plan de ejecución
`clear_cache()`	Borra los resultados en caché

Consulta Depuración para más información.

Métodos mágicos

Método	Descripción
`__getitem__(key)`	`ds['col']`, `ds[['a', 'b']]`, `ds[condition]`
`__setitem__(key, value)`	`ds['col'] = value`
`__delitem__(key)`	`del ds['col']`
`__len__()`	`len(ds)`
`__iter__()`	`for col in ds`
`__contains__(key)`	`'col' in ds`
`__repr__()`	`repr(ds)`
`__str__()`	`str(ds)`
`__eq__(other)`	`ds == other`
`__ne__(other)`	`ds != other`
`__lt__(other)`	`ds < other`
`__le__(other)`	`ds <= other`
`__gt__(other)`	`ds > other`
`__ge__(other)`	`ds >= other`
`__add__(other)`	`ds + other`
`__sub__(other)`	`ds - other`
`__mul__(other)`	`ds * other`
`__truediv__(other)`	`ds / other`
`__floordiv__(other)`	`ds // other`
`__mod__(other)`	`ds % other`
`__pow__(other)`	`ds ** other`
`__and__(other)`	`ds & other`
`__or__(other)`	`ds	other`
`__invert__()`	`~ds`
`__neg__()`	`-ds`
`__pos__()`	`+ds`
`__abs__()`	`abs(ds)`

ColumnExpr

Representa una expresión de columna para evaluación perezosa. Se devuelve al acceder a una columna.

# ColumnExpr se devuelve automáticamente
col = ds['name']  # Devuelve ColumnExpr

Propiedades

Propiedad	Tipo	Descripción
`name`	str	Nombre de la columna
`dtype`	dtype	Tipo de dato

Accesores

Accesor	Descripción	Métodos
`.str`	Operaciones con cadenas	56 métodos
`.dt`	Operaciones de fecha y hora	42+ métodos
`.arr`	Operaciones de Array	37 métodos
`.json`	Análisis de JSON	13 métodos
`.url`	Análisis de URL	15 métodos
`.ip`	Operaciones con direcciones IP	9 métodos
`.geo`	Operaciones de Geo/distancia	14 métodos

Consulta Accesores para ver la documentación completa.

Operaciones aritméticas

ds['total'] = ds['price'] * ds['quantity']
ds['profit'] = ds['revenue'] - ds['cost']
ds['ratio'] = ds['a'] / ds['b']
ds['squared'] = ds['value'] ** 2
ds['remainder'] = ds['value'] % 10

Operaciones de comparación

ds[ds['age'] > 25]           # Mayor que
ds[ds['age'] >= 25]          # Mayor o igual
ds[ds['age'] < 25]           # Menor que
ds[ds['age'] <= 25]          # Menor o igual
ds[ds['name'] == 'Alice']    # Igual
ds[ds['name'] != 'Bob']      # Distinto

Operaciones lógicas

ds[(ds['age'] > 25) & (ds['city'] == 'NYC')]    # AND
ds[(ds['age'] > 25) | (ds['city'] == 'NYC')]    # OR
ds[~(ds['status'] == 'inactive')]               # NOT

Métodos

Método	Descripción
`as_(alias)`	Establecer el nombre del alias
`cast(dtype)`	Convertir al tipo
`astype(dtype)`	Alias de cast
`isnull()`	Es NULL
`notnull()`	No es NULL
`isna()`	Alias de isnull
`notna()`	Alias de notnull
`isin(values)`	En una lista de valores
`between(low, high)`	Entre dos valores
`fillna(value)`	Rellenar valores NULL
`replace(to_replace, value)`	Reemplazar valores
`clip(lower, upper)`	Limitar valores
`abs()`	Valor absoluto
`round(decimals)`	Redondear valores
`floor()`	Redondear hacia abajo
`ceil()`	Redondear hacia arriba
`apply(func)`	Aplicar función
`map(mapper)`	Mapear valores

Métodos de agregación

Método	Descripción
`sum()`	Suma
`mean()`	Media
`avg()`	Alias de `mean()`
`min()`	Mínimo
`max()`	Máximo
`count()`	Recuento de valores no nulos
`nunique()`	Recuento de valores únicos
`std()`	Desviación estándar
`var()`	Varianza
`median()`	Mediana
`quantile(q)`	Cuantil
`first()`	Primer valor
`last()`	Último valor
`any()`	Al menos un true
`all()`	Todos true

LazyGroupBy

Representa un DataStore agrupado para realizar operaciones de agregación.

# LazyGroupBy se devuelve automáticamente
grouped = ds.groupby('category')  # Devuelve LazyGroupBy

Métodos

Método	Devuelve	Descripción
`agg(spec)`	DataStore	Agregación
`aggregate(spec)`	DataStore	Alias de agg
`sum()`	DataStore	Suma por grupo
`mean()`	DataStore	Media por grupo
`count()`	DataStore	Recuento por grupo
`min()`	DataStore	Mínimo por grupo
`max()`	DataStore	Máximo por grupo
`std()`	DataStore	Desviación estándar por grupo
`var()`	DataStore	Varianza por grupo
`median()`	DataStore	Mediana por grupo
`nunique()`	DataStore	Recuento de valores únicos por grupo
`first()`	DataStore	Primer valor por grupo
`last()`	DataStore	Último valor por grupo
`nth(n)`	DataStore	Enésimo valor por grupo
`head(n)`	DataStore	Primeros n por grupo
`tail(n)`	DataStore	Últimos n por grupo
`apply(func)`	DataStore	Aplicación de una función por grupo
`transform(func)`	DataStore	Transformación por grupo
`filter(func)`	DataStore	Filtrado de grupos

Selección de columnas

# Seleccionar columna después de groupby
grouped['amount'].sum()     # Devuelve DataStore
grouped[['a', 'b']].sum()   # Devuelve DataStore

Especificaciones de agregación

# Agregación única
grouped.agg({'amount': 'sum'})

# Múltiples agregaciones por columna
grouped.agg({'amount': ['sum', 'mean', 'count']})

# Agregaciones con nombre
grouped.agg(
    total=('amount', 'sum'),
    average=('amount', 'mean'),
    count=('id', 'count')
)

LazySeries

Representa una serie diferida (de una sola columna).

Propiedades

Propiedad	Tipo	Descripción
`name`	str	Nombre de la serie
`dtype`	dtype	Tipo de dato

Métodos

Hereda la mayoría de los métodos de ColumnExpr. Métodos principales:

Método	Descripción
`value_counts()`	Frecuencia de valores
`unique()`	Valores únicos
`nunique()`	Contar valores únicos
`mode()`	Valor más frecuente
`to_list()`	Convertir a lista
`to_numpy()`	Convertir a array
`to_frame()`	Convertir a DataStore

F (Funciones)

Espacio de nombres de las funciones de ClickHouse.

from chdb.datastore import F, Field

# Agregaciones
F.sum(Field('amount'))
F.avg(Field('price'))
F.count(Field('id'))
F.quantile(Field('value'), 0.95)

# Condicional
F.sum_if(Field('amount'), Field('status') == 'completed')
F.count_if(Field('active'))

# Ventana
F.row_number().over(order_by='date')
F.lag('price', 1).over(partition_by='product', order_by='date')

Consulte Agregación para obtener más detalles.

Campo

Referencia a una columna por nombre.

from chdb.datastore import Field

# Crear referencia de campo
amount = Field('amount')
price = Field('price')

# Usar en expresiones
F.sum(Field('amount'))
F.avg(Field('price'))

CaseWhen

Constructor para expresiones CASE WHEN.

# Crear una expresión case-when
result = (ds
    .when(ds['score'] >= 90, 'A')
    .when(ds['score'] >= 80, 'B')
    .when(ds['score'] >= 70, 'C')
    .otherwise('F')
)

# Asignar a la columna
ds['grade'] = result

Window

Especificación de ventana para las funciones de ventana.

from chdb.datastore import F

# Crear una ventana
window = F.window(
    partition_by='category',
    order_by='date',
    rows_between=(-7, 0)
)

# Usar con una agregación
ds['rolling_avg'] = F.avg('price').over(window)

​DataStore

​Constructor

​Propiedades

​Métodos de fábrica

​Métodos de consulta

​Métodos compatibles con Pandas

​Métodos de E/S

​Métodos de depuración

​Métodos mágicos

​ColumnExpr

​Propiedades

​Accesores

​Operaciones aritméticas

​Operaciones de comparación

​Operaciones lógicas

​Métodos

​Métodos de agregación

​LazyGroupBy

​Métodos

​Selección de columnas

​Especificaciones de agregación

​LazySeries

​Propiedades

​Métodos

​Clases relacionadas

​F (Funciones)

​Campo

​CaseWhen

​Window

DataStore

Constructor

Propiedades

Métodos de fábrica

Métodos de consulta

Métodos compatibles con Pandas

Métodos de E/S

Métodos de depuración

Métodos mágicos

ColumnExpr

Propiedades

Accesores

Operaciones aritméticas

Operaciones de comparación

Operaciones lógicas

Métodos

Métodos de agregación

LazyGroupBy

Métodos

Selección de columnas

Especificaciones de agregación

LazySeries

Propiedades

Métodos

Clases relacionadas

F (Funciones)

Campo

CaseWhen

Window