Métodos de fábrica de DataStore

Crear instancias de DataStore a partir de archivos, bases de datos, almacenamiento en la nube y lagos de datos

DataStore ofrece más de 20 métodos de fábrica para crear instancias a partir de diversas fuentes de datos, como archivos locales, bases de datos, almacenamiento en la nube y lagos de datos.

​

Interfaz URI universal

El método uri() es el punto de acceso universal recomendado, ya que detecta automáticamente el tipo de origen:

from chdb.datastore import DataStore

# Archivos locales
ds = DataStore.uri("data.csv")
ds = DataStore.uri("/path/to/data.parquet")

# Almacenamiento en la nube
ds = DataStore.uri("s3://bucket/data.parquet?nosign=true")
ds = DataStore.uri("https://example.com/data.csv")

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

​

Referencia de la sintaxis de URI

Tipo de origen	Formato de URI	Ejemplo
Archivo 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

---

​

Fuentes de archivo

​

from_file

Crea un DataStore a partir de un archivo local o remoto con detección automática del formato.

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

Parámetros:

Parámetro	Tipo	Predeterminado	Descripción
path	str	obligatorio	Ruta del archivo (local o URL)
format	str	None	Formato del archivo (se detecta automáticamente si es None)
compression	str	None	Tipo de compresión (se detecta automáticamente si es None)

Formatos compatibles: CSV, TSV, Parquet, JSON, JSONLines, ORC, Avro, Arrow

Ejemplos:

from chdb.datastore import DataStore

# Detectar formato automáticamente a partir de la extensión
ds = DataStore.from_file("data.csv")
ds = DataStore.from_file("data.parquet")
ds = DataStore.from_file("data.json")

# Formato explícito
ds = DataStore.from_file("data.txt", format="CSV")

# Con compresión
ds = DataStore.from_file("data.csv.gz", compression="gzip")

​

Funciones de lectura compatibles con Pandas

from chdb import datastore as pd

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

# Archivos Parquet (recomendados para conjuntos de datos grandes)
ds = pd.read_parquet("data.parquet")
ds = pd.read_parquet("data.parquet", columns=['col1', 'col2'])

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

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

---

​

Almacenamiento en la nube

​

from_s3

Crea un DataStore a partir de Amazon S3.

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

Parámetros:

Parámetro	Tipo	Predeterminado	Descripción
url	str	obligatorio	URL de S3 (s3://bucket/path)
access_key_id	str	None	ID de la clave de acceso de AWS
secret_access_key	str	None	Clave de acceso secreta de AWS
format	str	None	Formato de archivo (detectado automáticamente)

Ejemplos:

from chdb.datastore import DataStore

# Acceso anónimo (bucket público)
ds = DataStore.from_s3("s3://bucket/data.parquet")

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

# Usando URI con parámetros de consulta
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

Crea un DataStore desde Google Cloud Storage.

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

Ejemplos:

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

​

from_azure

Crea un DataStore a partir de Azure Blob Storage.

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

Ejemplos:

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

​

from_hdfs

Crea un DataStore a partir de HDFS.

DataStore.from_hdfs(url, **kwargs)

Ejemplos:

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

​

from_url

Crea un DataStore a partir de una URL HTTP/HTTPS.

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

Ejemplos:

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

---

​

Bases de datos

​

from_mysql

Crea un DataStore a partir de una base de datos MySQL.

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

Parámetros:

Parámetro	Tipo	Predeterminado	Descripción
host	str	obligatorio	Servidor MySQL
database	str	obligatorio	Nombre de la base de datos
table	str	obligatorio	Nombre de la tabla
user	str	obligatorio	Nombre de usuario
password	str	obligatorio	Contraseña
port	int	3306	Número de puerto

Ejemplos:

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

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

​

from_postgresql

Crear un DataStore a partir de una base de datos PostgreSQL.

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

Ejemplos:

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

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

​

from_clickhouse

Crear un DataStore a partir del servidor de ClickHouse.

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

Ejemplos:

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

# Modo de nivel de conexión (explorar bases de datos)
ds = DataStore.from_clickhouse(
    host="analytics.company.com",
    user="analyst",
    password="secret"
)
ds.databases()                  # Listar bases de datos
ds.tables("production")         # Listar tablas
result = ds.sql("SELECT * FROM production.users LIMIT 10")

​

from_mongodb

Crea un DataStore a partir de MongoDB.

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

Ejemplos:

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

​

from_sqlite

Crea un DataStore a partir de una base de datos SQLite.

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

Ejemplos:

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

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

---

​

Lagos de datos

​

from_iceberg

Crea un DataStore a partir de una tabla Apache Iceberg.

DataStore.from_iceberg(path, **kwargs)

Ejemplos:

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

​

from_delta

Crea un DataStore a partir de una tabla de Delta Lake.

DataStore.from_delta(path, **kwargs)

Ejemplos:

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

​

from_hudi

Crea un DataStore a partir de una tabla Hudi.

DataStore.from_hudi(path, **kwargs)

Ejemplos:

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

---

​

Fuentes en memoria

​

from_df / from_dataframe

Crea un DataStore a partir de un DataFrame de pandas.

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

Ejemplos:

import pandas
from chdb.datastore import DataStore

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

​

Constructor de DataFrame

Cree un DataStore con un constructor similar al de pandas.

from chdb import datastore as pd

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

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

---

​

Fuentes especiales

​

from_numbers

Crea un DataStore con números secuenciales (útil para pruebas).

DataStore.from_numbers(count, **kwargs)

Ejemplos:

ds = DataStore.from_numbers(1000000)  # 1M filas con columna 'number'
result = ds.filter(ds['number'] % 2 == 0).head(10)  # Números pares

​

from_random

Crear un DataStore con datos aleatorios.

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

Ejemplos:

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

​

run_sql

Crear un DataStore a partir de una consulta SQL en bruto.

DataStore.run_sql(query)

Ejemplos:

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

---

​

Tabla de resumen

Método	Tipo de origen	Ejemplo
uri()	Universal	DataStore.uri("s3://bucket/data.parquet")
from_file()	Archivos locales/remotos	DataStore.from_file("data.csv")
read_csv()	Archivos CSV	pd.read_csv("data.csv")
read_parquet()	Archivos 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()	DataFrame de pandas	DataStore.from_df(pandas_df)
DataFrame()	Diccionario/DataFrame	pd.DataFrame({'a': [1, 2, 3]})
from_numbers()	Números secuenciales	DataStore.from_numbers(1000000)
from_random()	Datos aleatorios	DataStore.from_random(rows=1000, columns=5)
run_sql()	consulta SQL en bruto	DataStore.run_sql("SELECT * FROM ...")