Référence de la classe DataStore

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)

Référence de la classe DataStore

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