Référence de la classe DataStore - ClickHouse Documentation

Cette référence présente les principales classes de l’API DataStore.

DataStore

La principale classe de type DataFrame pour manipuler les données.

from chdb.datastore import DataStore

Constructeur

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

Paramètres :

Paramètre	Type	Description
`data`	dict/list/DataFrame/DataStore	Données d’entrée
`columns`	list	Noms des colonnes
`index`	Index	Index des lignes
`dtype`	dict	Types de données des colonnes
`copy`	bool	Copier les données

Exemples :

# 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()

Propriétés

Propriété	Type	Description
`columns`	Index	Noms des colonnes
`dtypes`	Series	Types de données des colonnes
`shape`	tuple	(lignes, colonnes)
`size`	int	Nombre total d’éléments
`ndim`	int	Nombre de dimensions (2)
`empty`	bool	Indique si le DataFrame est vide
`values`	ndarray	Données sous-jacentes sous forme de tableau NumPy
`index`	Index	Index des lignes
`T`	DataStore	Transposition
`axes`	list	Liste des axes

Méthodes de fabrique

Méthode	Description
`uri(uri)`	Méthode de fabrique universelle à partir d’un URI
`from_file(path, ...)`	Créer à partir d’un fichier
`from_df(df)`	Créer à partir d’un DataFrame pandas
`from_s3(url, ...)`	Créer à partir de S3
`from_gcs(url, ...)`	Créer à partir de Google Cloud Storage
`from_azure(url, ...)`	Créer à partir d’un blob Azure
`from_mysql(...)`	Créer à partir de MySQL
`from_postgresql(...)`	Créer à partir de PostgreSQL
`from_clickhouse(...)`	Créer à partir de ClickHouse
`from_mongodb(...)`	Créer à partir de MongoDB
`from_sqlite(...)`	Créer à partir de SQLite
`from_iceberg(path)`	Créer à partir d’une table Iceberg
`from_delta(path)`	Créer à partir de Delta Lake
`from_numbers(n)`	Créer avec des nombres séquentiels
`from_random(rows, cols)`	Créer avec des données aléatoires
`run_sql(query)`	Créer à partir d’une requête SQL

Voir Méthodes de fabrique pour en savoir plus.

Méthodes de requête

Méthode	Renvoie	Description
`select(*cols)`	DataStore	Sélectionner des colonnes
`filter(condition)`	DataStore	Filtrer les lignes
`where(condition)`	DataStore	Alias de `filter`
`sort(*cols, ascending=True)`	DataStore	Trier les lignes
`orderby(*cols)`	DataStore	Alias de `sort`
`limit(n)`	DataStore	Limiter les lignes
`offset(n)`	DataStore	Ignorer des lignes
`distinct(subset=None)`	DataStore	Supprimer les doublons
`groupby(*cols)`	LazyGroupBy	Regrouper les lignes
`having(condition)`	DataStore	Filtrer les groupes
`join(right, ...)`	DataStore	Joindre des DataStores
`union(other, all=False)`	DataStore	Combiner des DataStores
`when(cond, val)`	CaseWhen	CASE WHEN

Voir Construction de requêtes pour plus de détails.

Méthodes compatibles avec pandas

Consultez Compatibilité avec pandas pour obtenir la liste complète des 209 méthodes. Indexation : head(), tail(), sample(), loc, iloc, at, iat, query(), isin(), where(), mask(), get(), xs(), pop() Agrégation : sum(), mean(), std(), var(), min(), max(), median(), count(), nunique(), quantile(), describe(), corr(), cov(), skew(), kurt() Manipulation : drop(), drop_duplicates(), dropna(), fillna(), replace(), rename(), assign(), astype(), copy() Tri : sort_values(), sort_index(), nlargest(), nsmallest(), rank() Remise en forme : pivot(), pivot_table(), melt(), stack(), unstack(), transpose(), explode(), squeeze() Combinaison : merge(), join(), concat(), append(), combine(), update(), compare() Application/Transformation : apply(), applymap(), map(), agg(), transform(), pipe(), groupby() Séries temporelles : rolling(), expanding(), ewm(), shift(), diff(), pct_change(), resample()

Méthodes d’E/S

Méthode	Description
`to_csv(path, ...)`	Exporter au format CSV
`to_parquet(path, ...)`	Exporter au format Parquet
`to_json(path, ...)`	Exporter au format JSON
`to_excel(path, ...)`	Exporter au format Excel
`to_df()`	Convertir en DataFrame pandas
`to_pandas()`	alias de to_df
`to_arrow()`	Convertir en Arrow Table
`to_dict(orient)`	Convertir en dictionnaire
`to_records()`	Convertir en enregistrements
`to_numpy()`	Convertir en tableau NumPy
`to_sql()`	Générer une chaîne SQL
`to_string()`	Représentation sous forme de chaîne
`to_markdown()`	Tableau Markdown
`to_html()`	Tableau HTML

Voir les opérations d’E/S pour plus de détails.

Méthodes de débogage

Méthode	Description
`explain(verbose=False)`	Afficher le plan d’exécution
`clear_cache()`	Vider les résultats mis en cache

Voir Débogage pour plus de détails.

Méthodes spéciales

Méthode	Description
`__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

Représente une expression de colonne pour l’évaluation paresseuse. Renvoyée lorsqu’on accède à une colonne.

# ColumnExpr is returned automatically
col = ds['name']  # Returns ColumnExpr

Propriétés

Propriété	Type	Description
`name`	str	Nom de la colonne
`dtype`	dtype	Type de données

Accesseurs

Accesseur	Description	Méthodes
`.str`	Opérations sur les chaînes	56 méthodes
`.dt`	Opérations DateTime	42+ méthodes
`.arr`	Opérations sur les tableaux	37 méthodes
`.json`	Analyse du JSON	13 méthodes
`.url`	Analyse des URL	15 méthodes
`.ip`	Opérations sur les adresses IP	9 méthodes
`.geo`	Opérations Geo/de distance	14 méthodes

Voir Accessors pour la documentation complète.

Opérations arithmétiques

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

Opérations de comparaison

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

Opérations logiques

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

Méthodes

Méthode	Description
`as_(alias)`	Définir le nom d’alias
`cast(dtype)`	Convertir vers un type
`astype(dtype)`	alias de cast
`isnull()`	Est NULL
`notnull()`	N’est pas NULL
`isna()`	alias de isnull
`notna()`	alias de notnull
`isin(values)`	Appartient à une liste de valeurs
`between(low, high)`	Entre deux valeurs
`fillna(value)`	Remplir les valeurs NULL
`replace(to_replace, value)`	Remplacer des valeurs
`clip(lower, upper)`	Borner les valeurs
`abs()`	Valeur absolue
`round(decimals)`	Arrondir les valeurs
`floor()`	Arrondi inférieur
`ceil()`	Arrondi supérieur
`apply(func)`	Appliquer une fonction
`map(mapper)`	Transformer les valeurs

Méthodes d’agrégation

Méthode	Description
`sum()`	Somme
`mean()`	Moyenne
`avg()`	alias de mean
`min()`	Minimum
`max()`	Maximum
`count()`	Nombre de valeurs non NULL
`nunique()`	Nombre de valeurs uniques
`std()`	Écart type
`var()`	Variance
`median()`	Médiane
`quantile(q)`	Quantile
`first()`	Première valeur
`last()`	Dernière valeur
`any()`	Au moins une valeur true
`all()`	Toutes les valeurs true

LazyGroupBy

Représente un DataStore regroupé pour les opérations d’agrégation.

# LazyGroupBy is returned automatically
grouped = ds.groupby('category')  # Returns LazyGroupBy

Méthodes

Méthode	Renvoie	Description
`agg(spec)`	DataStore	Agrège
`aggregate(spec)`	DataStore	alias de agg
`sum()`	DataStore	Somme de chaque groupe
`mean()`	DataStore	Moyenne de chaque groupe
`count()`	DataStore	Nombre d’éléments par groupe
`min()`	DataStore	Minimum de chaque groupe
`max()`	DataStore	Maximum de chaque groupe
`std()`	DataStore	Écart-type par groupe
`var()`	DataStore	Variance par groupe
`median()`	DataStore	Médiane de chaque groupe
`nunique()`	DataStore	Nombre de valeurs uniques par groupe
`first()`	DataStore	Première valeur de chaque groupe
`last()`	DataStore	Dernière valeur de chaque groupe
`nth(n)`	DataStore	Nième valeur de chaque groupe
`head(n)`	DataStore	n premières valeurs par groupe
`tail(n)`	DataStore	n dernières valeurs par groupe
`apply(func)`	DataStore	Applique une fonction à chaque groupe
`transform(func)`	DataStore	Transforme chaque groupe
`filter(func)`	DataStore	Filtre les groupes

Sélection des colonnes

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

Spécifications d’agrégation

# 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

Représente une série à évaluation différée (une seule colonne).

Propriétés

Propriété	Type	Description
`name`	str	Nom de la série
`dtype`	dtype	Type de données

Méthodes

Hérite de la plupart des méthodes de ColumnExpr. Principales méthodes :

Méthode	Description
`value_counts()`	Fréquences des valeurs
`unique()`	Valeurs uniques
`nunique()`	Nombre de valeurs uniques
`mode()`	Valeur la plus fréquente
`to_list()`	Convertir en liste
`to_numpy()`	Convertir en tableau
`to_frame()`	Convertir en DataStore

F (Fonctions)

Espace de noms des fonctions 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')

Voir Agrégation pour en savoir plus.

Champ

Référence à une colonne par son nom.

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

Objet de construction pour les expressions 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

Spécification de fenêtre pour les fonctions de fenêtrage.

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)

​DataStore

​Constructeur

​Propriétés

​Méthodes de fabrique

​Méthodes de requête

​Méthodes compatibles avec pandas

​Méthodes d’E/S

​Méthodes de débogage

​Méthodes spéciales

​ColumnExpr

​Propriétés

​Accesseurs

​Opérations arithmétiques

​Opérations de comparaison

​Opérations logiques

​Méthodes

​Méthodes d’agrégation

​LazyGroupBy

​Méthodes

​Sélection des colonnes

​Spécifications d’agrégation

​LazySeries

​Propriétés

​Méthodes

​Classes associées

​F (Fonctions)

​Champ

​CaseWhen

​Window

DataStore

Constructeur

Propriétés

Méthodes de fabrique

Méthodes de requête

Méthodes compatibles avec pandas

Méthodes d’E/S

Méthodes de débogage

Méthodes spéciales

ColumnExpr

Propriétés

Accesseurs

Opérations arithmétiques

Opérations de comparaison

Opérations logiques

Méthodes

Méthodes d’agrégation

LazyGroupBy

Méthodes

Sélection des colonnes

Spécifications d’agrégation

LazySeries

Propriétés

Méthodes

Classes associées

F (Fonctions)

Champ

CaseWhen

Window