> ## Documentation Index
> Fetch the complete documentation index at: https://clickhouse.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Фабричные методы DataStore

> Создание экземпляров DataStore из файлов, баз данных, облачных хранилищ и озер данных

DataStore включает более 20 фабричных методов для создания экземпляров из различных источников данных, включая локальные файлы, базы данных, облачные хранилища и озера данных.

## Универсальный интерфейс URI

Метод `uri()` — рекомендуемая универсальная точка входа с автоматическим определением типа источника:

```python theme={null}
from chdb.datastore import DataStore

# Локальные файлы
ds = DataStore.uri("data.csv")
ds = DataStore.uri("/path/to/data.parquet")

# Облачные хранилища
ds = DataStore.uri("s3://bucket/data.parquet?nosign=true")
ds = DataStore.uri("https://example.com/data.csv")

# Базы данных
ds = DataStore.uri("mysql://user:pass@host:3306/db/table")
ds = DataStore.uri("postgresql://user:pass@host:5432/db/table")
```

### Справочник по синтаксису URI

| Тип источника | Формат URI | Пример |
| - | - | - |
| Локальный файл | `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` |

***

## Файловые источники

### `from_file`

Создаёт DataStore из локального или удалённого файла с автоматическим определением формата.

```python theme={null}
DataStore.from_file(path, format=None, compression=None, **kwargs)
```

**Параметры:**

| Параметр | Тип | По умолчанию | Описание |
| - | - | - | - |
| `path` | str | *обязательно* | Путь к файлу (локальный путь или URL) |
| `format` | str | `None` | Формат файла (если указано None, определяется автоматически) |
| `compression` | str | `None` | Тип сжатия (если указано None, определяется автоматически) |

**Поддерживаемые форматы:** CSV, TSV, Parquet, JSON, JSONLines, ORC, Avro, Arrow

**Примеры:**

```python theme={null}
from chdb.datastore import DataStore

# Автоматическое определение формата по расширению
ds = DataStore.from_file("data.csv")
ds = DataStore.from_file("data.parquet")
ds = DataStore.from_file("data.json")

# Явное указание формата
ds = DataStore.from_file("data.txt", format="CSV")

# Со сжатием
ds = DataStore.from_file("data.csv.gz", compression="gzip")
```

### Функции чтения, совместимые с Pandas

```python theme={null}
from chdb import datastore as pd

# CSV-файлы
ds = pd.read_csv("data.csv")
ds = pd.read_csv("data.csv", sep=";", header=0, nrows=1000)

# Файлы Parquet (рекомендуется для больших датасетов)
ds = pd.read_parquet("data.parquet")
ds = pd.read_parquet("data.parquet", columns=['col1', 'col2'])

# JSON-файлы
ds = pd.read_json("data.json")
ds = pd.read_json("data.jsonl", lines=True)

# Файлы Excel
ds = pd.read_excel("data.xlsx", sheet_name="Sheet1")
```

***

## Облачное хранилище

### `from_s3`

Создание DataStore из Amazon S3.

```python theme={null}
DataStore.from_s3(url, access_key_id=None, secret_access_key=None, format=None, **kwargs)
```

**Параметры:**

| Параметр | Тип | По умолчанию | Описание |
| - | - | - | - |
| `url` | str | *обязательно* | URL-адрес S3 (s3://bucket/path) |
| `access_key_id` | str | `None` | Идентификатор ключа доступа AWS |
| `secret_access_key` | str | `None` | Секретный ключ доступа AWS |
| `format` | str | `None` | Формат файла (определяется автоматически) |

**Примеры:**

```python theme={null}
from chdb.datastore import DataStore

# Анонимный доступ (общедоступный бакет)
ds = DataStore.from_s3("s3://bucket/data.parquet")

# С учетными данными
ds = DataStore.from_s3(
    "s3://bucket/data.parquet",
    access_key_id="AKIAIOSFODNN7EXAMPLE",
    secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
)

# Использование URI с параметрами запроса
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`

Создать DataStore из Google Cloud Storage.

```python theme={null}
DataStore.from_gcs(url, credentials_path=None, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_gcs("gs://bucket/data.parquet")
ds = DataStore.from_gcs("gs://bucket/data.parquet", credentials_path="/path/to/creds.json")
```

### `from_azure`

Создает DataStore из Azure Blob Storage.

```python theme={null}
DataStore.from_azure(url, account_name=None, account_key=None, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_azure(
    "az://container/data.parquet",
    account_name="myaccount",
    account_key="mykey"
)
```

### `from_hdfs`

Создаёт DataStore из HDFS.

```python theme={null}
DataStore.from_hdfs(url, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_hdfs("hdfs://namenode:8020/path/data.parquet")
```

### `from_url`

Создаёт DataStore по URL HTTP/HTTPS.

```python theme={null}
DataStore.from_url(url, format=None, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_url("https://example.com/data.csv")
ds = DataStore.from_url("https://raw.githubusercontent.com/user/repo/main/data.parquet")
```

***

## Базы данных

### `from_mysql`

Создание DataStore из базы данных MySQL.

```python theme={null}
DataStore.from_mysql(host, database, table, user, password, port=3306, **kwargs)
```

**Параметры:**

| Параметр | Тип | По умолчанию | Описание |
| - | - | - | - |
| `host` | str | *required* | Хост MySQL |
| `database` | str | *required* | Имя базы данных |
| `table` | str | *required* | Имя таблицы |
| `user` | str | *required* | Имя пользователя |
| `password` | str | *required* | Пароль |
| `port` | int | `3306` | Номер порта |

**Примеры:**

```python theme={null}
ds = DataStore.from_mysql(
    host="localhost",
    database="mydb",
    table="users",
    user="root",
    password="password"
)

# Использование URI
ds = DataStore.uri("mysql://root:password@localhost:3306/mydb/users")
```

### `from_postgresql`

Создать DataStore из базы данных PostgreSQL.

```python theme={null}
DataStore.from_postgresql(host, database, table, user, password, port=5432, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_postgresql(
    host="localhost",
    database="mydb",
    table="users",
    user="postgres",
    password="password"
)

# Использование URI
ds = DataStore.uri("postgresql://postgres:password@localhost:5432/mydb/users")
```

### `from_clickhouse`

Создает DataStore на основе сервера ClickHouse.

```python theme={null}
DataStore.from_clickhouse(host, database, table, user=None, password=None, port=9000, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_clickhouse(
    host="localhost",
    database="default",
    table="hits",
    user="default",
    password=""
)

# Режим на уровне подключения (просмотр баз данных)
ds = DataStore.from_clickhouse(
    host="analytics.company.com",
    user="analyst",
    password="secret"
)
ds.databases()                  # Список баз данных
ds.tables("production")         # Список таблиц
result = ds.sql("SELECT * FROM production.users LIMIT 10")
```

### `from_mongodb`

Создание DataStore из MongoDB.

```python theme={null}
DataStore.from_mongodb(uri, database, collection, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_mongodb(
    uri="mongodb://localhost:27017",
    database="mydb",
    collection="users"
)
```

### `from_sqlite`

Создает DataStore из базы данных SQLite.

```python theme={null}
DataStore.from_sqlite(database_path, table, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_sqlite("data.db", table="users")

# Использование URI
ds = DataStore.uri("sqlite:///data.db?table=users")
```

***

## Озера данных

### `from_iceberg`

Создаёт DataStore на основе таблицы Apache Iceberg.

```python theme={null}
DataStore.from_iceberg(path, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_iceberg("/path/to/iceberg_table")
ds = DataStore.uri("iceberg://catalog/namespace/table")
```

### `from_delta`

Создает DataStore из таблицы Delta Lake.

```python theme={null}
DataStore.from_delta(path, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_delta("/path/to/delta_table")
ds = DataStore.uri("deltalake:///path/to/delta_table")
```

### `from_hudi`

Создает DataStore на основе таблицы Apache Hudi.

```python theme={null}
DataStore.from_hudi(path, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_hudi("/path/to/hudi_table")
ds = DataStore.uri("hudi:///path/to/hudi_table")
```

***

## Источники в памяти

### `from_df` / `from_dataframe`

Создаёт DataStore из pandas DataFrame.

```python theme={null}
DataStore.from_df(df, name=None)
DataStore.from_dataframe(df, name=None)  # псевдоним
```

**Примеры:**

```python theme={null}
import pandas
from chdb.datastore import DataStore

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

### Конструктор `DataFrame`

Создайте DataStore с помощью конструктора, аналогичного pandas.

```python theme={null}
from chdb import datastore as pd

# Из словаря
ds = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30]
})

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

***

## Специальные источники

### `from_numbers`

Создаёт DataStore с последовательными числами (полезно для тестирования).

```python theme={null}
DataStore.from_numbers(count, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_numbers(1000000)  # 1M строк со столбцом 'number'
result = ds.filter(ds['number'] % 2 == 0).head(10)  # Чётные числа
```

### `from_random`

Создаёт DataStore со случайными данными.

```python theme={null}
DataStore.from_random(rows, columns, **kwargs)
```

**Примеры:**

```python theme={null}
ds = DataStore.from_random(rows=1000, columns=5)
```

### `run_sql`

Создает DataStore из SQL-запроса Raw SQL.

```python theme={null}
DataStore.run_sql(query)
```

**Примеры:**

```python theme={null}
ds = DataStore.run_sql("""
    SELECT number, number * 2 as doubled
    FROM numbers(100)
    WHERE number % 10 = 0
""")
```

***

## Сводная таблица

| Метод | Тип источника | Пример |
| - | - | - |
| `uri()` | Универсальный | `DataStore.uri("s3://bucket/data.parquet")` |
| `from_file()` | Локальные/удалённые файлы | `DataStore.from_file("data.csv")` |
| `read_csv()` | CSV-файлы | `pd.read_csv("data.csv")` |
| `read_parquet()` | Файлы 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()` | словарь / DataFrame | `pd.DataFrame({'a': [1, 2, 3]})` |
| `from_numbers()` | Последовательные числа | `DataStore.from_numbers(1000000)` |
| `from_random()` | Случайные данные | `DataStore.from_random(rows=1000, columns=5)` |
| `run_sql()` | Raw SQL | `DataStore.run_sql("SELECT * FROM ...")` |