Méthodes de fabrique de DataStore

Créer des instances DataStore à partir de fichiers, de bases de données, de stockage dans le cloud et de lacs de données

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 ...")