Méthodes de fabrique de DataStore - ClickHouse Documentation

DataStore propose plus de 20 méthodes de fabrique pour créer des instances à partir de différentes sources de données, notamment des fichiers locaux, des bases de données, du stockage dans le cloud et des lacs de données.

Interface URI universelle

La méthode uri() est le point d’accès universel recommandé, qui détecte automatiquement le type de source :

from chdb.datastore import DataStore

# Local files
ds = DataStore.uri("data.csv")
ds = DataStore.uri("/path/to/data.parquet")

# Cloud storage
ds = DataStore.uri("s3://bucket/data.parquet?nosign=true")
ds = DataStore.uri("https://example.com/data.csv")

# Databases
ds = DataStore.uri("mysql://user:pass@host:3306/db/table")
ds = DataStore.uri("postgresql://user:pass@host:5432/db/table")

Référence de la syntaxe des URI

Type de source	Format d’URI	Exemple
Fichier local	`path/to/file`	`data.csv`, `/abs/path/data.parquet`
S3	`s3://bucket/path`	`s3://mybucket/data.parquet?nosign=true`
GCS	`gs://bucket/path`	`gs://mybucket/data.csv`
Azure	`az://container/path`	`az://mycontainer/data.parquet`
HTTP/HTTPS	`https://url`	`https://example.com/data.csv`
MySQL	`mysql://user:pass@host:port/db/table`	`mysql://root:pass@localhost:3306/mydb/users`
PostgreSQL	`postgresql://user:pass@host:port/db/table`	`postgresql://postgres:pass@localhost:5432/mydb/users`
SQLite	`sqlite:///path?table=name`	`sqlite:///data.db?table=users`
ClickHouse	`clickhouse://host:port/db/table`	`clickhouse://localhost:9000/default/hits`

Sources de données de type fichier

`from_file`

Créer un DataStore à partir d’un fichier local ou distant, avec détection automatique du format.

DataStore.from_file(path, format=None, compression=None, **kwargs)

Paramètres :

Paramètre	Type	Par défaut	Description
`path`	str	obligatoire	Chemin de fichier (local ou URL)
`format`	str	`None`	Format de fichier (détecté automatiquement si None)
`compression`	str	`None`	Type de compression (détecté automatiquement si None)

Formats pris en charge : CSV, TSV, Parquet, JSON, JSONLines, ORC, Avro, Arrow Exemples :

from chdb.datastore import DataStore

# Auto-detect format from extension
ds = DataStore.from_file("data.csv")
ds = DataStore.from_file("data.parquet")
ds = DataStore.from_file("data.json")

# Explicit format
ds = DataStore.from_file("data.txt", format="CSV")

# With compression
ds = DataStore.from_file("data.csv.gz", compression="gzip")

Fonctions de lecture compatibles avec Pandas

from chdb import datastore as pd

# CSV files
ds = pd.read_csv("data.csv")
ds = pd.read_csv("data.csv", sep=";", header=0, nrows=1000)

# Parquet files (recommended for large datasets)
ds = pd.read_parquet("data.parquet")
ds = pd.read_parquet("data.parquet", columns=['col1', 'col2'])

# JSON files
ds = pd.read_json("data.json")
ds = pd.read_json("data.jsonl", lines=True)

# Excel files
ds = pd.read_excel("data.xlsx", sheet_name="Sheet1")

Stockage Cloud

`from_s3`

Créer un DataStore depuis Amazon S3.

DataStore.from_s3(url, access_key_id=None, secret_access_key=None, format=None, **kwargs)

Paramètres :

Paramètre	Type	Par défaut	Description
`url`	str	obligatoire	URL S3 (s3://bucket/path)
`access_key_id`	str	`None`	ID de la clé d’accès AWS
`secret_access_key`	str	`None`	Clé d’accès secrète AWS
`format`	str	`None`	Format de fichier (détecté automatiquement)

Exemples :

from chdb.datastore import DataStore

# Anonymous access (public bucket)
ds = DataStore.from_s3("s3://bucket/data.parquet")

# With credentials
ds = DataStore.from_s3(
    "s3://bucket/data.parquet",
    access_key_id="AKIAIOSFODNN7EXAMPLE",
    secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
)

# Using URI with query parameters
ds = DataStore.uri("s3://bucket/data.parquet?nosign=true")
ds = DataStore.uri("s3://bucket/data.parquet?access_key_id=KEY&secret_access_key=SECRET")

`from_gcs`

Créer un DataStore depuis Google Cloud Storage.

DataStore.from_gcs(url, credentials_path=None, **kwargs)

Exemples :

ds = DataStore.from_gcs("gs://bucket/data.parquet")
ds = DataStore.from_gcs("gs://bucket/data.parquet", credentials_path="/path/to/creds.json")

`from_azure`

Créer un DataStore depuis Azure Blob Storage.

DataStore.from_azure(url, account_name=None, account_key=None, **kwargs)

Exemples :

ds = DataStore.from_azure(
    "az://container/data.parquet",
    account_name="myaccount",
    account_key="mykey"
)

`from_hdfs`

Créer un DataStore depuis HDFS.

DataStore.from_hdfs(url, **kwargs)

Exemples :

ds = DataStore.from_hdfs("hdfs://namenode:8020/path/data.parquet")

`from_url`

Créer un DataStore à partir d’une URL HTTP/HTTPS.

DataStore.from_url(url, format=None, **kwargs)

Exemples :

ds = DataStore.from_url("https://example.com/data.csv")
ds = DataStore.from_url("https://raw.githubusercontent.com/user/repo/main/data.parquet")

Bases de données

`from_mysql`

Créer un DataStore à partir d’une base de données MySQL.

DataStore.from_mysql(host, database, table, user, password, port=3306, **kwargs)

Paramètres :

Paramètre	Type	Par défaut	Description
`host`	str	obligatoire	Hôte MySQL
`database`	str	obligatoire	Nom de la base de données
`table`	str	obligatoire	Nom de la table
`user`	str	obligatoire	Nom d’utilisateur
`password`	str	obligatoire	Mot de passe
`port`	int	`3306`	Numéro de port

Exemples :

ds = DataStore.from_mysql(
    host="localhost",
    database="mydb",
    table="users",
    user="root",
    password="password"
)

# Using URI
ds = DataStore.uri("mysql://root:password@localhost:3306/mydb/users")

`from_postgresql`

Créer un DataStore à partir d’une base de données PostgreSQL.

DataStore.from_postgresql(host, database, table, user, password, port=5432, **kwargs)

Exemples :

ds = DataStore.from_postgresql(
    host="localhost",
    database="mydb",
    table="users",
    user="postgres",
    password="password"
)

# Using URI
ds = DataStore.uri("postgresql://postgres:password@localhost:5432/mydb/users")

`from_clickhouse`

Créer un DataStore à partir du serveur ClickHouse.

DataStore.from_clickhouse(host, database, table, user=None, password=None, port=9000, **kwargs)

Exemples :

ds = DataStore.from_clickhouse(
    host="localhost",
    database="default",
    table="hits",
    user="default",
    password=""
)

# Connection-level mode (explore databases)
ds = DataStore.from_clickhouse(
    host="analytics.company.com",
    user="analyst",
    password="secret"
)
ds.databases()                  # List databases
ds.tables("production")         # List tables
result = ds.sql("SELECT * FROM production.users LIMIT 10")

`from_mongodb`

Crée un DataStore à partir de MongoDB.

DataStore.from_mongodb(uri, database, collection, **kwargs)

Exemples :

ds = DataStore.from_mongodb(
    uri="mongodb://localhost:27017",
    database="mydb",
    collection="users"
)

`from_sqlite`

Créez un DataStore à partir d’une base de données SQLite.

DataStore.from_sqlite(database_path, table, **kwargs)

Exemples :

ds = DataStore.from_sqlite("data.db", table="users")

# Using URI
ds = DataStore.uri("sqlite:///data.db?table=users")

Lacs de données

`from_iceberg`

Créer un DataStore à partir d’une table Iceberg Apache.

DataStore.from_iceberg(path, **kwargs)

Exemples :

ds = DataStore.from_iceberg("/path/to/iceberg_table")
ds = DataStore.uri("iceberg://catalog/namespace/table")

`from_delta`

Créer un DataStore à partir d’une table Delta Lake.

DataStore.from_delta(path, **kwargs)

Exemples :

ds = DataStore.from_delta("/path/to/delta_table")
ds = DataStore.uri("deltalake:///path/to/delta_table")

`from_hudi`

Créer un DataStore à partir d’une table Apache Hudi.

DataStore.from_hudi(path, **kwargs)

Exemples :

ds = DataStore.from_hudi("/path/to/hudi_table")
ds = DataStore.uri("hudi:///path/to/hudi_table")

Sources en mémoire

`from_df` / `from_dataframe`

Créer un DataStore à partir d’un DataFrame pandas.

DataStore.from_df(df, name=None)
DataStore.from_dataframe(df, name=None)  # alias

Exemples :

import pandas
from chdb.datastore import DataStore

pdf = pandas.DataFrame({'a': [1, 2, 3], 'b': ['x', 'y', 'z']})
ds = DataStore.from_df(pdf)

Constructeur `DataFrame`

Créez un DataStore à l’aide d’un constructeur similaire à ceux de pandas.

from chdb import datastore as pd

# From dictionary
ds = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30]
})

# From pandas DataFrame
import pandas
pdf = pandas.DataFrame({'a': [1, 2, 3]})
ds = pd.DataFrame(pdf)

Sources spéciales

`from_numbers`

Crée un DataStore avec des nombres séquentiels (utile pour les tests).

DataStore.from_numbers(count, **kwargs)

Exemples :

ds = DataStore.from_numbers(1000000)  # 1M rows with 'number' column
result = ds.filter(ds['number'] % 2 == 0).head(10)  # Even numbers

`from_random`

Créez un DataStore à partir de données aléatoires.

DataStore.from_random(rows, columns, **kwargs)

Exemples :

ds = DataStore.from_random(rows=1000, columns=5)

`run_sql`

Créer un DataStore à partir d’une requête Raw SQL.

DataStore.run_sql(query)

Exemples :

ds = DataStore.run_sql("""
    SELECT number, number * 2 as doubled
    FROM numbers(100)
    WHERE number % 10 = 0
""")

Tableau récapitulatif

Méthode	Type de source	Exemple
`uri()`	Universel	`DataStore.uri("s3://bucket/data.parquet")`
`from_file()`	Fichiers locaux/distants	`DataStore.from_file("data.csv")`
`read_csv()`	Fichiers CSV	`pd.read_csv("data.csv")`
`read_parquet()`	Fichiers Parquet	`pd.read_parquet("data.parquet")`
`from_s3()`	Amazon S3	`DataStore.from_s3("s3://bucket/path")`
`from_gcs()`	Google Cloud Storage	`DataStore.from_gcs("gs://bucket/path")`
`from_azure()`	Azure Blob	`DataStore.from_azure("az://container/path")`
`from_hdfs()`	HDFS	`DataStore.from_hdfs("hdfs://host/path")`
`from_url()`	HTTP/HTTPS	`DataStore.from_url("https://example.com/data.csv")`
`from_mysql()`	MySQL	`DataStore.from_mysql(host, db, table, user, pass)`
`from_postgresql()`	PostgreSQL	`DataStore.from_postgresql(host, db, table, user, pass)`
`from_clickhouse()`	ClickHouse	`DataStore.from_clickhouse(host, db, table)`
`from_mongodb()`	MongoDB	`DataStore.from_mongodb(uri, db, collection)`
`from_sqlite()`	SQLite	`DataStore.from_sqlite("data.db", table)`
`from_iceberg()`	Apache Iceberg	`DataStore.from_iceberg("/path/to/table")`
`from_delta()`	Delta Lake	`DataStore.from_delta("/path/to/table")`
`from_hudi()`	Apache Hudi	`DataStore.from_hudi("/path/to/table")`
`from_df()`	pandas DataFrame	`DataStore.from_df(pandas_df)`
`DataFrame()`	Dictionnaire / DataFrame	`pd.DataFrame({'a': [1, 2, 3]})`
`from_numbers()`	Nombres séquentiels	`DataStore.from_numbers(1000000)`
`from_random()`	Données aléatoires	`DataStore.from_random(rows=1000, columns=5)`
`run_sql()`	SQL brut	`DataStore.run_sql("SELECT * FROM ...")`

​Interface URI universelle

​Référence de la syntaxe des URI

​Sources de données de type fichier

​from_file

​Fonctions de lecture compatibles avec Pandas

​Stockage Cloud

​from_s3

​from_gcs

​from_azure

​from_hdfs

​from_url

​Bases de données

​from_mysql

​from_postgresql

​from_clickhouse

​from_mongodb

​from_sqlite

​Lacs de données

​from_iceberg

​from_delta

​from_hudi

​Sources en mémoire

​from_df / from_dataframe

​Constructeur DataFrame

​Sources spéciales

​from_numbers

​from_random

​run_sql

​Tableau récapitulatif

Interface URI universelle

Référence de la syntaxe des URI

Sources de données de type fichier

`from_file`

Fonctions de lecture compatibles avec Pandas

Stockage Cloud

`from_s3`

`from_gcs`

`from_azure`

`from_hdfs`

`from_url`

Bases de données

`from_mysql`

`from_postgresql`

`from_clickhouse`

`from_mongodb`

`from_sqlite`

Lacs de données

`from_iceberg`

`from_delta`

`from_hudi`

Sources en mémoire

`from_df` / `from_dataframe`

Constructeur `DataFrame`

Sources spéciales

`from_numbers`

`from_random`

`run_sql`

Tableau récapitulatif