Referencia de la class DataStore

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

DataStore

La principal clase de tipo DataFrame para la manipulación de 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 las columnas
`index`	Index	Índice de filas
`dtype`	dict	Tipos de datos de las columnas
`copy`	bool	Copiar los datos

Ejemplos:

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

# From pandas DataFrame
import pandas as pd

ds = DataStore(pd.DataFrame({'a': [1, 2, 3]}))

# Empty DataStore
ds = DataStore()

Propiedades

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

Métodos de fábrica

Método	Descripción
`uri(uri)`	Método de fábrica universal a partir de un URI
`from_file(path, ...)`	Crear a partir de un archivo
`from_df(df)`	Crear a partir de un pandas DataFrame
`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	Omitir 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 más detalles.

Métodos compatibles con Pandas

Consulta Compatibilidad con Pandas para obtener 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()

Aplicar/Transformar: 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 pandas DataFrame
`to_pandas()`	Alias de to_df
`to_arrow()`	Convertir a tabla 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

Consulta Operaciones de E/S para obtener más información.

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 obtener 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 de evaluación diferida. Se devuelve al acceder a una columna.

# ColumnExpr is returned automatically
col = ds['name']  # Returns 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 de String	56 métodos
`.dt`	Operaciones de DateTime	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

Consulte Accesores para acceder a 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]           # Greater than
ds[ds['age'] >= 25]          # Greater or equal
ds[ds['age'] < 25]           # Less than
ds[ds['age'] <= 25]          # Less or equal
ds[ds['name'] == 'Alice']    # Equal
ds[ds['name'] != 'Bob']      # Not equal

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 indicado
`astype(dtype)`	Alias para cast
`isnull()`	Es NULL
`notnull()`	No es NULL
`isna()`	Alias para isnull
`notna()`	Alias para notnull
`isin(values)`	Está 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)`	Recortar valores
`abs()`	Valor absoluto
`round(decimals)`	Redondear valores
`floor()`	Redondeo hacia abajo
`ceil()`	Redondeo 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()`	Conteo de valores no nulos
`nunique()`	Conteo de valores únicos
`std()`	Desviación estándar
`var()`	Varianza
`median()`	Mediana
`quantile(q)`	Cuantil
`first()`	Primer valor
`last()`	Último valor
`any()`	Cualquier valor verdadero
`all()`	Todos los valores verdaderos

LazyGroupBy

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

# LazyGroupBy is returned automatically
grouped = ds.groupby('category')  # Returns 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	Aplica una función por grupo
`transform(func)`	DataStore	Transforma por grupo
`filter(func)`	DataStore	Filtra grupos

Selección de columnas

# Select column after groupby
grouped['amount'].sum()     # Returns DataStore
grouped[['a', 'b']].sum()   # Returns DataStore

Especificaciones de agregación

# Single aggregation
grouped.agg({'amount': 'sum'})

# Multiple aggregations per column
grouped.agg({'amount': ['sum', 'mean', 'count']})

# Named aggregations
grouped.agg(
    total=('amount', 'sum'),
    average=('amount', 'mean'),
    count=('id', 'count')
)

LazySeries

Representa una Series 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 clave:

Método	Descripción
`value_counts()`	Frecuencia de valores
`unique()`	Valores únicos
`nunique()`	Recuento de valores únicos
`mode()`	Valor modal
`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

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

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

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

Consulta Agregación para obtener más información.

Field

Referencia a una columna por su nombre.

from chdb.datastore import Field

# Create field reference
amount = Field('amount')
price = Field('price')

# Use in expressions
F.sum(Field('amount'))
F.avg(Field('price'))

CaseWhen

Constructor de expresiones CASE WHEN.

# Create case-when expression
result = (ds
    .when(ds['score'] >= 90, 'A')
    .when(ds['score'] >= 80, 'B')
    .when(ds['score'] >= 70, 'C')
    .otherwise('F')
)

# Assign to column
ds['grade'] = result

Window

Especificación de Window para funciones de ventana.

from chdb.datastore import F

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

# Use with aggregation
ds['rolling_avg'] = F.avg('price').over(window)

Referencia de la class DataStore

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)

Field

CaseWhen

Window