первый commit

2025-12-03 16:35:50 +03:00
commit 41bbdecba5
19 changed files with 1478 additions and 0 deletions
@@ -0,0 +1,23 @@
 .ipynb_checkpoints
 __pycache__/
 # Python bytecode / build artifacts
 *.py[cod]
 *.pyo
 *.pyd
 *.egg-info/
 *.egg
 # Virtual environments
 .venv/
 venv/
 # Editor / IDE settings
 .idea/
 .vscode/
 # Local config
 .env
 # Logs
 *.log
@@ -0,0 +1,56 @@
 # Repository Guidelines
 This repository contains a small teaching Lakehouse stack (Spark + Trino + Iceberg + MinIO) intended for demos and mentoring.
 ## Project Structure & Module Organization
 - `docker-compose.yml`: orchestrates Spark, Trino, MinIO, PostgreSQL, and Jupyter.
 - `spark/`: Spark image (`Dockerfile`) and `spark-defaults.conf`.
 - `jupyter/`: Jupyter image (`Dockerfile`) based on the Spark image.
 - `trino/`: catalog config, e.g. `trino/catalog/lakehouse.properties`.
 - `src/`: PySpark and SQL examples split by engine (`src/spark/...`, `src/trino/...`).
 - `notebooks/`: demo notebooks (mounted into Jupyter at `/opt/work`).
 Keep new examples in `src/` or `notebooks/`, and avoid mixing configuration and code.
 ## Build, Test, and Development Commands
 Run from the repo root:
 - `docker compose build`: build custom Spark and Jupyter images.
 - `docker compose up -d`: start the full stack in the background.
 - `docker compose ps`: check container status.
 - `docker compose down -v`: stop the stack and remove volumes (for a clean slate).
 Use `docker compose logs -f <service>` when debugging (`spark-master`, `trino`, `minio`, etc.).
 ## Coding Style & Naming Conventions
 - Python: PEP 8, 4-space indentation, snake_case for functions, lower_snake_case for files (e.g. `spark_join_demo.py`).
 - SQL: uppercase keywords, `schema.table` naming, short English identifiers; comments may be in Russian.
 - Compose/Docker: service names kebab-case (`spark-master`), env vars UPPER_SNAKE_CASE.
 - Prefer small, focused examples; reuse helpers from `src/` in notebooks where possible.
 ## Testing Guidelines
 There is no formal automated test suite yet. Validate changes by:
 - building and starting the stack, then
 - running `src/spark/cluster_smoke.py` or the SQL in `src/spark/iceberg_demo.sql`,
 - opening `notebooks/spark-basic-test.ipynb` in Jupyter and checking it runs end-to-end.
 If you add tests, prefer `pytest` under `tests/` and mark slow, integration-heavy tests clearly.
 ## Commit & Pull Request Guidelines
 - Commits: short, descriptive subject in Russian or English, present tense (e.g. `Спарк запускается, создаётся тестовая таблица`, `Add Iceberg join demo`).
 - Keep changes small and focused; update `README.md` when behavior, ports, or images change.
 - PRs should describe the problem, the solution, and any impact on local setup; include screenshots (Trino UI, MinIO, Jupyter) when UI changes are relevant.
 ## Agent-Specific Instructions
 When editing as an automated agent:
 - Respect this file and avoid large refactors without an explicit request.
 - Preserve Russian user-facing text unless the change is explicitly about translation.
 - Prefer minimal changes that keep the demo simple and robust for newcomers.
@@ -0,0 +1,298 @@
 # HOWTO: Учебные лабораторные по Lakehouse-стенду
 Этот файл описывает пошаговые учебные сценарии (лабораторные работы), которые можно выполнять поверх стенда из `docker-compose.yml`.
 Перед началом работ смотри разделы «Сборка и запуск» и «Доступ к сервисам» в `README.md` — там описано, как поднять стенд и на каких портах доступны Trino, MinIO, Spark и Jupyter.
 Лабораторки опираются на примеры в `src/`:
 - `src/spark/cluster_smoke.py` — проверка, что Spark‑кластер жив.
 - `src/spark/iceberg_demo.sql` — первая Iceberg‑таблица в Spark.
 - `src/spark/iceberg_smoke.py` — Spark создаёт Iceberg‑таблицу и читает её.
 - `src/trino/iceberg_smoke.sql` — Trino читает таблицу, созданную в Spark.
 Все команды ниже выполняются из корня репозитория.
 Краткая карта лабораторных:
 - **Лаба 0** — стенд поднят, Spark‑кластер жив.
 - **Лаба 1** — первая Iceberg‑таблица в Spark.
 - **Лаба 2** — общий каталог Spark ↔ Trino.
 - **Лаба 3** — партиционирование и эволюция схемы.
 - **Лаба 4** — мини‑ETL поверх Lakehouse (эскиз).
 ---
 ## Лаба 0. Стенд поднят, Spark‑кластер жив
 **Цель**
 - Убедиться, что все контейнеры поднялись.
 - Проверить, что Spark‑кластер (master + workers) работает.
 **Предусловия**
 - Установлены Docker и Docker Compose.
 - Репозиторий склонирован локально.
 **Шаги**
 1. Собрать и поднять стенд:
   ```bash
   docker compose build
   docker compose up -d
   ```
 2. Проверить статус контейнеров:
   ```bash
   docker compose ps
   ```
   Ожидаем, что `spark-master`, `spark-worker-1`, `spark-worker-2` в статусе `Up`.
 3. Запустить smoke‑скрипт кластера из контейнера `spark-master`:
   ```bash
   docker compose exec spark-master \
     /opt/spark/bin/spark-submit /opt/src/spark/cluster_smoke.py
   ```
 4. Открыть Web UI Spark:
 - `http://localhost:8080` — мастер.
 - `http://localhost:8081` и `http://localhost:8082` — воркеры.
 **Ожидаемый результат**
 - `cluster_smoke.py` выполняется без ошибок.
 - В Web UI видно приложение, прошедшее через кластер.
 ---
 ## Лаба 1. Первая Iceberg‑таблица из Spark
 **Цель**
 - Создать Iceberg‑таблицу с помощью Spark SQL.
 - Посмотреть файлы таблицы в MinIO (`warehouse/default/demo_tbl/...`).
 **Предусловия**
 - Стенд запущен (лаба 0 выполнена).
 **Шаги**
 1. Подключиться к Spark SQL в контейнере:
   ```bash
   docker compose exec -it spark-master \
     /opt/spark/bin/spark-sql
   ```
 2. Выполнить учебный SQL‑скрипт:
 - Внутри интерактивной сессии `spark-sql`:
  ```sql
  :r /opt/src/spark/iceberg_demo.sql
  ```
 - Либо одним вызовом (без интерактивного режима):
  ```bash
  docker compose exec spark-master \
    /opt/spark/bin/spark-sql -f /opt/src/spark/iceberg_demo.sql
  ```
 3. Зайти в MinIO Console:
 - Адрес: `http://localhost:9001`
 - Учётные данные по умолчанию: `minioadmin / minioadmin` (см. `docker-compose.yml`).
 4. Найти файлы таблицы:
 - Бакет `lakehouse`.
 - Префикс `warehouse/default/demo_tbl/`.
 - Обратить внимание на структуру Iceberg: каталоги `metadata/`, `data/` и т.д.
 **Ожидаемый результат**
 - В Spark запрос
  ```sql
  SELECT * FROM lakehouse.default.demo_tbl;
  ```
  возвращает данные.
 - В MinIO видна структура Iceberg‑таблицы: служебные файлы и файлы данных.
 ---
 ## Лаба 2. Общий каталог Spark ↔ Trino
 **Цель**
 - Показать, что Spark и Trino используют общий Iceberg‑каталог (метаданные в Postgres, данные в MinIO).
 - Создать таблицу из Spark и прочитать её через Trino.
 **Предусловия**
 - Стенд запущен.
 - Лаба 1 не обязательна, но полезна для понимания структуры файлов.
 **Шаги**
 1. Создать таблицу и записать данные из Spark (PySpark‑скрипт):
   ```bash
   docker compose exec spark-master \
     /opt/spark/bin/spark-submit /opt/src/spark/iceberg_smoke.py
   ```
 2. Убедиться в Spark, что таблица существует:
   ```bash
   docker compose exec -it spark-master \
     /opt/spark/bin/spark-sql
   ```
   В интерактивной сессии:
   ```sql
   USE lakehouse.default;
   SHOW TABLES;
   SELECT * FROM spark_trino_smoke;
   ```
 3. Прочитать ту же таблицу из Trino:
 - Вариант через заранее скопированный SQL‑файл (как в README):
  ```bash
  docker compose cp src/trino/iceberg_smoke.sql trino:/tmp/
  docker compose exec trino trino --file /tmp/iceberg_smoke.sql
  ```
 - Либо интерактивно внутри Trino CLI:
  ```bash
  docker compose exec -it trino trino --catalog lakehouse
  ```
  Внутри CLI:
  ```sql
  USE lakehouse.default;
  SHOW TABLES;
  SELECT * FROM spark_trino_smoke;
  ```
 **Ожидаемый результат**
 - Таблица `spark_trino_smoke` видна и в Spark, и в Trino.
 - Данные совпадают (например, строка `1, from_spark`).
 ---
 ## Лаба 3. Партиционирование и эволюция схемы
 **Цель**
 - Показать, как Iceberg работает с партиционированием (фильтрация по partition key, уменьшение объёма чтения).
 - Показать, как Iceberg поддерживает эволюцию схемы без сложных миграций.
 **Предусловия**
 - Стенд запущен.
 - Желательно выполнить Лабы 1–2, чтобы уже была интуиция про Iceberg и общий каталог.
 **Подготовленные примеры**
 - `src/spark/partitioned_table_demo.sql` — создание партиционированной Iceberg‑таблицы и вставка данных.
 - `src/spark/schema_evolution_demo.sql` — демонстрация `ALTER TABLE` и добавления колонок.
 - `src/trino/schema_evolution_demo.sql` — чтение той же таблицы с эволюцией схемы из Trino.
 - `notebooks/03_partitioning_and_schema_evolution.ipynb` — интерактивный разбор тех же примеров в Jupyter.
 **Вариант A: через Spark SQL и Trino CLI**
 1. Создать партиционированную таблицу в Spark:
   ```bash
   docker compose exec spark-master \
     /opt/spark/bin/spark-sql -f /opt/src/spark/partitioned_table_demo.sql
   ```
 2. Проверить в Spark, какие данные записаны по датам:
   ```bash
   docker compose exec -it spark-master \
     /opt/spark/bin/spark-sql
   ```
   Внутри интерактивной сессии:
   ```sql
   USE lakehouse.default;
   SELECT event_date, COUNT(*) AS cnt, SUM(amount) AS total_amount
   FROM partition_demo
   GROUP BY event_date
   ORDER BY event_date;
   ```
 3. Подготовить таблицу с эволюцией схемы:
   ```bash
   docker compose exec spark-master \
     /opt/spark/bin/spark-sql -f /opt/src/spark/schema_evolution_demo.sql
   ```
 4. Посмотреть схему и данные в Spark:
   ```bash
   docker compose exec -it spark-master \
     /opt/spark/bin/spark-sql
   ```
   Внутри:
   ```sql
   USE lakehouse.default;
   DESCRIBE TABLE schema_evolution_demo;
   SELECT * FROM schema_evolution_demo ORDER BY id;
   ```
 5. Прочитать таблицу с эволюцией схемы из Trino:
   ```bash
   docker compose cp src/trino/schema_evolution_demo.sql trino:/tmp/
   docker compose exec trino trino --file /tmp/schema_evolution_demo.sql
   ```
 **Вариант B: через Jupyter‑ноутбук**
 - Открыть `http://localhost:8888` и запустить ноутбук `03_partitioning_and_schema_evolution.ipynb`.
 - Ноутбук:
  - создаёт SparkSession, подключённый к кластеру;
  - выполняет скрипты `partitioned_table_demo.sql` и `schema_evolution_demo.sql`;
  - показывает агрегаты по партициям и данные до/после эволюции схемы в интерактивном виде.
 ---
 ## Лаба 4. Мини‑ETL поверх Lakehouse (эскиз)
 Идея лабы — собрать end-to-end сценарий:
 - есть сырые данные (CSV/JSON) в S3/MinIO;
 - Spark читает raw‑данные, чистит и пишет в Iceberg‑таблицу;
 - Trino делает поверх неё аналитику.
 Планируемые компоненты:
 - Папка с примерами сырых данных (например, `examples/raw/` в репозитории, затем загрузка в MinIO).
 - `src/spark/etl_raw_to_iceberg.py` — мини ETL, записывающий данные в `lakehouse.default.events` или аналогичную таблицу.
 - `src/trino/etl_analytics.sql` — несколько аналитических запросов поверх этой таблицы.
 Детали реализации можно развивать по мере появления новых сценариев.
@@ -0,0 +1,15 @@
 Creative Commons Attribution 4.0 International (CC BY 4.0)
 This work is licensed under the Creative Commons Attribution 4.0 International License.
 You are free to:
 - Share — copy and redistribute the material in any medium or format.
 - Adapt — remix, transform, and build upon the material for any purpose, even commercially.
 Under the following terms:
 - Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made.
 - No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
 The full text of the license is available at:
 https://creativecommons.org/licenses/by/4.0/legalcode
@@ -0,0 +1,390 @@
 # Учебный Lakehouse-стенд (Trino + Spark + Iceberg + MinIO)
 Учебный стенд для демонстрации **Lakehouse-архитектуры** на одном ноутбуке:
 - объектное хранилище S3-класса (MinIO),
 - движок запросов Trino,
 - Spark для batch/ETL и интерактивных экспериментов,
 - формат таблиц Iceberg,
 - JDBC-каталог (PostgreSQL) для метаданных Iceberg в Trino,
 - конфиг Spark, заточенный под работу с Iceberg + S3.
 Стенд ориентирован на обучение менти и быструю демонстрацию концепции Lakehouse: разделение **storage / compute / catalog** без лишней обвязки (Hive Metastore, полноценный Hadoop-кластер и т.п.).
 ---
 ## Архитектура
 ```mermaid
 graph LR
    subgraph Storage
        M[(MinIO<br/>S3-compatible)]
    end
    subgraph Catalog
        P[(PostgreSQL<br/>Iceberg JDBC catalog)]
    end
    subgraph Compute
        S[Spark 3.5.1<br/>PySpark / SQL]
        T[Trino 478<br/>Iceberg connector]
    end
    S <--> M
    T <--> M
    T <--> P
 ```
 **Основные идеи:**
 * **Данные** (Parquet-файлы + служебные каталоги Iceberg) лежат в бакете MinIO (`s3a://lakehouse/warehouse/...`).
 * **Метаданные** Iceberg хранятся в PostgreSQL (JDBC-каталог `lakehouse`).
 * **Spark и Trino** используют один и тот же JDBC-каталог: таблицы, созданные в Spark, доступны в Trino, и наоборот.
 ---
 ## Быстрый старт
 1. Установить Docker и Docker Compose (см. раздел «Требования» ниже).
 2. В корне репозитория выполнить:
   ```bash
   docker compose build
   docker compose up -d
   ```
 3. Открыть основные интерфейсы:
   - Trino Web UI: `http://localhost:8090`
   - MinIO Console: `http://localhost:9001`
   - JupyterLab (если включён): `http://localhost:8888`
 4. Для пошаговых лабораторных работ см. файл `HOWTO.md`.
 ---
 ## Состав репозитория
 * `docker-compose.yml` — описание всех сервисов стенда:
  * Spark master / worker(ы) на базе кастомного образа `spark-iceberg`,
  * Trino,
  * MinIO (S3-совместимое хранилище),
  * PostgreSQL под Iceberg JDBC-каталог,
  * (опционально) Jupyter / notebook для PySpark.
 * `spark/Dockerfile` — сборка кастомного образа **Spark** с зависимостями:
  * `hadoop-aws`, `aws-java-sdk`,
  * библиотека Iceberg нужной версии,
  * `pyspark`, `pyarrow` и базовый набор инструментов.
 * `jupyter/Dockerfile` — образ JupyterLab на базе Spark-образа.
 * `spark/spark-defaults.conf` — конфигурация Spark для работы с:
  * Iceberg-каталогом `lakehouse` (тип `jdbc`, метаданные в Postgres),
  * MinIO через `s3a://`,
  * расширениями `IcebergSparkSessionExtensions`.
 * `src/` — учебные примеры для Spark и Trino:
  * `src/spark/cluster_smoke.py` — проверка, что кластер жив (Spark master/worker).
  * `src/spark/iceberg_smoke.py` — Spark создаёт Iceberg-таблицу и читает её.
  * `src/spark/iceberg_demo.sql` — пример создания Iceberg-таблицы через Spark SQL.
  * `src/trino/iceberg_smoke.sql` — Trino читает таблицу, созданную в Spark.
 * `trino/catalog/lakehouse.properties` — конфиг каталога Trino `lakehouse`:
  * коннектор `iceberg`,
  * `jdbc`-каталог (PostgreSQL),
  * доступ к MinIO как к S3-хранилищу.
 ---
 ## Требования
 - Docker и Docker Compose.
 - Порты по умолчанию должны быть свободны (см. таблицу «Сервисы и порты» ниже).
 ### Сервисы и порты
 | Сервис                 | Контейнер         | Порт (host → container) | Назначение / UI                     |
 |------------------------|-------------------|-------------------------|-------------------------------------|
 | Trino                  | `trino`           | `8090 → 8080`           | Web UI Trino                        |
 | MinIO API              | `minio`           | `9000 → 9000`           | S3 endpoint                         |
 | MinIO Console          | `minio`           | `9001 → 9001`           | Веб-консоль MinIO                   |
 | PostgreSQL (каталог)   | `postgres-iceberg`| `5432 → 5432`           | Доступ для psql/DBeaver и т.п.      |
 | Spark master UI        | `spark-master`    | `8080 → 8080`           | Web UI мастера Spark                |
 | Spark worker-1 UI      | `spark-worker-1`  | `8081 → 8081`           | Web UI первого воркера              |
 | Spark worker-2 UI      | `spark-worker-2`  | `8082 → 8081`           | Web UI второго воркера (host 8082)  |
 | JupyterLab             | `jupyter`         | `8888 → 8888`           | JupyterLab с PySpark                |
 ---
 ## Сборка и запуск
 Все команды в этом разделе выполняются из корня репозитория.
 ### 1. Собрать образы
 ```bash
 docker compose build
 ```
 Будут собраны кастомные образы Spark/Jupyter с зависимостями Iceberg, S3A, JDBC-драйвером Postgres и Python-библиотеками.
 ### 2. Поднять стенд
 ```bash
 docker compose up -d
 ```
 Что происходит при старте:
 * MinIO поднимается с root-пользователем/паролем (по умолчанию смотри в `docker-compose.yml`, обычно `minioadmin/minioadmin`), init-контейнер создаёт бакет `lakehouse`.
 * PostgreSQL под каталог Iceberg создаёт БД и пользователя (значения — в `docker-compose.yml` / `.env`).
 * Trino стартует с каталогом `lakehouse`, описанным в `lakehouse.properties`.
 * Spark master/worker получают конфиг из `spark-defaults.conf` (общий JDBC-каталог Iceberg + MinIO).
 Проверить статус:
 ```bash
 docker compose ps
 ```
 ### 3. Остановить стенд и очистить данные
 Чтобы остановить все сервисы и удалить данные в MinIO/PostgreSQL (Docker volumes), можно выполнить:
 ```bash
 docker compose down -v
 ```
 ---
 ## Доступ к сервисам
 ### Trino
 Web UI (координатор):
 ```text
 http://localhost:8090
 ```
 (точный порт см. в `docker-compose.yml`).
 Подключение **из контейнера trino**:
 ```bash
 docker exec -it trino trino \
  --server http://localhost:8080 \
  --catalog lakehouse
 ```
 Проверка:
 ```sql
 SHOW CATALOGS;
 SHOW SCHEMAS FROM lakehouse;
 ```
 ### MinIO
 * Консоль: `http://localhost:9001`
 * S3 endpoint: `http://localhost:9000`
 Учётные данные — `MINIO_ROOT_USER` / `MINIO_ROOT_PASSWORD` из `docker-compose.yml` или `.env`.
 Создай в MinIO бакет `lakehouse` (если его нет) — данные Iceberg будут храниться именно там.
 ### PostgreSQL (каталог Iceberg для Trino)
 Подключение (пример):
 ```bash
 psql -h localhost -p 5432 -U iceberg -d iceberg
 ```
 (имя пользователя, БД и порт уточняются в `docker-compose.yml`).
 Служебные таблицы Iceberg JDBC-каталога (`iceberg_tables`, `iceberg_namespace_properties`) создаёт однократный контейнер `iceberg-catalog-init`. Если база уже запускалась без них, можно переинициализировать вручную:
 ```bash
 docker compose run --rm iceberg-catalog-init
 ```
 ### Jupyter / notebooks
 Веб-интерфейс: `http://localhost:8888` (по умолчанию без токена).
 * В контейнере монтируется `./notebooks` в `/opt/work`.
 * `./src` доступен read-only в `/opt/src`, переменная `PYTHONPATH=/opt/src` уже установлена — можно импортировать функции из скриптов прямо в ноутбуках.
 ---
 ## Конфигурация Trino (каталог `lakehouse`)
 Файл `lakehouse.properties` монтируется в `/etc/trino/catalog/lakehouse.properties`.
 Ключевые параметры:
 ```properties
 connector.name=iceberg
 # Каталог Iceberg типа JDBC (метаданные в PostgreSQL)
 iceberg.catalog.type=jdbc
 iceberg.jdbc-catalog.catalog-name=lakehouse
 iceberg.jdbc-catalog.driver-class=org.postgresql.Driver
 iceberg.jdbc-catalog.connection-url=jdbc:postgresql://postgres-iceberg:5432/iceberg
 iceberg.jdbc-catalog.connection-user=iceberg
 iceberg.jdbc-catalog.connection-password=iceberg
 iceberg.jdbc-catalog.schema-version=V1
 # Хранилище файлов Iceberg – S3 (MinIO) через hadoop-клиент
 iceberg.file-system.type=hadoop
 fs.native-s3.enabled=true
 s3.endpoint=http://minio:9000
 s3.region=us-east-1
 s3.path-style-access=true
 s3.aws-access-key=minioadmin
 s3.aws-secret-key=minioadmin
 ```
 **Что это даёт:**
 * Trino хранит *метаданные* Iceberg в PostgreSQL (таблицы каталога, снапшоты, манифесты и т.п.).
 * *Файлы данных* лежат в MinIO, в бакете `lakehouse`, к которому Trino ходит по `s3://`/`s3a://` через S3-клиент.
 Пример создания схемы и таблицы из Trino:
 ```sql
 -- Схема в каталоге lakehouse (метаданные в PostgreSQL)
 CREATE SCHEMA lakehouse.default;
 -- Таблица Iceberg с данными в s3://lakehouse/default/test_table/
 CREATE TABLE lakehouse.default.test_table (
    id   bigint,
    name varchar
 );
 ```
 ---
 ## Конфигурация Spark (spark-defaults.conf)
 `spark-defaults.conf` монтируется в `/opt/spark/conf/spark-defaults.conf` в контейнеры Spark.
 Ключевые моменты:
 ```properties
 # Iceberg Spark extensions
 spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
 # Каталог Iceberg для Spark (JDBC, метаданные в Postgres)
 spark.sql.catalog.lakehouse=org.apache.iceberg.spark.SparkCatalog
 spark.sql.catalog.lakehouse.catalog-impl=org.apache.iceberg.jdbc.JdbcCatalog
 spark.sql.catalog.lakehouse.uri=jdbc:postgresql://postgres-iceberg:5432/iceberg
 spark.sql.catalog.lakehouse.jdbc.user=iceberg
 spark.sql.catalog.lakehouse.jdbc.password=iceberg
 spark.sql.catalog.lakehouse.jdbc.driver=org.postgresql.Driver
 spark.sql.catalog.lakehouse.warehouse=s3a://lakehouse/warehouse
 spark.sql.catalog.lakehouse.default-namespace=default
 # S3/MinIO через s3a
 spark.hadoop.fs.s3a.endpoint=http://minio:9000
 spark.hadoop.fs.s3a.access.key=minioadmin
 spark.hadoop.fs.s3a.secret.key=minioadmin
 spark.hadoop.fs.s3a.path.style.access=true
 spark.hadoop.fs.s3a.impl=org.apache.hadoop.fs.s3a.S3AFileSystem
 spark.hadoop.fs.s3a.connection.ssl.enabled=false
 ```
 **Важно:** Spark и Trino используют единый JDBC-каталог `lakehouse`: метаданные лежат в Postgres, данные — в MinIO. Таблица, созданная в Spark, видна в Trino без дополнительной настройки.
 Пример создания таблицы из Spark:
 ```python
 from pyspark.sql import SparkSession
 spark = (SparkSession.builder
         .appName("lakehouse-demo")
         .getOrCreate())
 # Каталог lakehouse указан явно
 spark.sql("""
    CREATE TABLE lakehouse.default.spark_table (
        id   BIGINT,
        name STRING
    )
    USING iceberg
 """)
 spark.sql("INSERT INTO lakehouse.default.spark_table VALUES (1, 'Alice'), (2, 'Bob')")
 ```
 Файлы окажутся в `s3a://lakehouse/warehouse/default/spark_table/`.
 ---
 ## Типовой учебный сценарий
 1. **Поднять стенд** (`docker compose build`, затем `docker compose up -d`).
 2. **Создать бакет `lakehouse`** в MinIO Console (если ещё нет).
 3. **Создать таблицу из Spark**, записать туда данные, показать дерево файлов Iceberg в MinIO (data/manifest/metadata).
 4. **Прочитать ту же таблицу из Trino** (проверка общего каталога).
 5. **Создать таблицу из Trino** и прочитать её из Spark.
 6. Обсудить архитектуру: Postgres хранит метаданные Iceberg, MinIO — данные, Spark/Trino — compute.
 ---
 ## Smoke-тесты Spark → Trino
 Быстрая проверка, что таблица, созданная в Spark, читается в Trino через общий JDBC-каталог.
 1. Убедиться, что стенд запущен: `docker compose up -d`.
 2. Скопировать скрипты внутрь контейнеров:
   ```bash
   docker compose cp src/spark/iceberg_smoke.py spark-master:/tmp/
   docker compose cp src/trino/iceberg_smoke.sql trino:/tmp/
   ```
 3. Выполнить smoke из Spark:
   ```bash
   docker compose exec spark-master /opt/spark/bin/spark-submit /tmp/iceberg_smoke.py
   ```
   Скрипт создаст `lakehouse.default.spark_trino_smoke`, вставит строку `1, from_spark` и прочитает её.
 4. Прочитать ту же таблицу из Trino:
   ```bash
   docker compose exec trino trino --file /tmp/iceberg_smoke.sql
   ```
   В выводе должны быть строки `spark_trino_smoke` в списке таблиц и `1, from_spark` в результате выборки.
 5. Очистка (опционально):
   ```bash
   docker compose exec spark-master /opt/spark/bin/spark-sql -e "DROP TABLE IF EXISTS lakehouse.default.spark_trino_smoke"
   ```
 ---
 ## Дальнейшее развитие
 Планируемые/возможные расширения:
 * Подключить **Airflow** и запускать Spark-job’ы поверх этого же Lakehouse.
 * Вынести настройки (`MINIO_ROOT_USER`, `ICEBERG_*`, `POSTGRES_*`) в `.env` с шаблоном для студентов.
 * Добавить отдельные каталоги Trino (например, `hive`, `tpch`) для демонстрации федеративных запросов.
 * Добавить пример интеграции с BI-инструментом (DBeaver/Metabase/Superset) поверх Trino.
 Для пошаговых учебных сценариев (лабораторных работ) см. файл `HOWTO.md`.
 ---
 ## Лицензия
 Материалы этого репозитория лицензированы на условиях Creative Commons Attribution 4.0 International (CC BY 4.0).  
 См. файл `LICENSE` или <https://creativecommons.org/licenses/by/4.0/>.
@@ -0,0 +1,209 @@
 # version: "3.9"
 services:
  postgres:
    image: postgres:16
    container_name: postgres-iceberg
    environment:
      POSTGRES_DB: iceberg          # БД под Iceberg catalog
      POSTGRES_USER: iceberg
      POSTGRES_PASSWORD: iceberg
    ports:
      - "5432:5432"                 # опционально, чтобы заходить с хоста через DBeaver/psql
    networks:
      - spark-net
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U iceberg -d iceberg || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 5
  iceberg-catalog-init:
    image: postgres:16
    container_name: iceberg-catalog-init
    depends_on:
      - postgres
    networks:
      - spark-net
    environment:
      - PGPASSWORD=iceberg
    entrypoint: |
      /bin/sh -c "set -e
      echo 'Waiting for Postgres (iceberg catalog)...'
      until pg_isready -h postgres-iceberg -U iceberg -d iceberg; do
        sleep 1
      done
      cat <<'SQL' | psql -h postgres-iceberg -U iceberg -d iceberg
      CREATE TABLE IF NOT EXISTS iceberg_tables (
        catalog_name VARCHAR(255) NOT NULL,
        table_namespace VARCHAR(255) NOT NULL,
        table_name VARCHAR(255) NOT NULL,
        metadata_location VARCHAR(1000),
        previous_metadata_location VARCHAR(1000),
        iceberg_type VARCHAR(5),
        PRIMARY KEY (catalog_name, table_namespace, table_name)
      );
      CREATE TABLE IF NOT EXISTS iceberg_namespace_properties (
        catalog_name VARCHAR(255) NOT NULL,
        namespace VARCHAR(255) NOT NULL,
        property_key VARCHAR(255),
        property_value VARCHAR(1000),
        PRIMARY KEY (catalog_name, namespace, property_key)
      );
      SQL
      echo 'Iceberg JDBC catalog tables are ready'
      "
  spark-master:
    build:
      context: ./spark
    image: de-spark-iceberg:3.5.1
    container_name: spark-master
    hostname: spark-master
    depends_on:
      - postgres
    networks:
      - spark-net
    environment:
      - SPARK_NO_DAEMONIZE=true
      - AWS_ACCESS_KEY_ID=minioadmin
      - AWS_SECRET_ACCESS_KEY=minioadmin
    command: ["/opt/spark/sbin/start-master.sh"]
    ports:
      - "7077:7077"   # Spark master
      - "8080:8080"   # Web UI мастера
    volumes:
      - ./spark/spark-defaults.conf:/opt/spark/conf/spark-defaults.conf:ro
  spark-worker-1:
    image: de-spark-iceberg:3.5.1
    # build:
    #   context: ./spark    
    container_name: spark-worker-1
    hostname: spark-worker-1
    networks:
      - spark-net
    environment:
      - SPARK_NO_DAEMONIZE=true
      - SPARK_WORKER_CORES=2
      - SPARK_WORKER_MEMORY=2g
      - AWS_ACCESS_KEY_ID=minioadmin
      - AWS_SECRET_ACCESS_KEY=minioadmin
    command: ["/opt/spark/sbin/start-worker.sh", "spark://spark-master:7077"]
    depends_on:
      - spark-master
    ports:
      - "8081:8081"   # Web UI первого воркера
    volumes:
      - ./spark/spark-defaults.conf:/opt/spark/conf/spark-defaults.conf:ro
  spark-worker-2:
    image: de-spark-iceberg:3.5.1
    # build:
    #   context: ./spark
    container_name: spark-worker-2
    hostname: spark-worker-2
    networks:
      - spark-net
    environment:
      - SPARK_NO_DAEMONIZE=true
      - SPARK_WORKER_CORES=2
      - SPARK_WORKER_MEMORY=2g
      - AWS_ACCESS_KEY_ID=minioadmin
      - AWS_SECRET_ACCESS_KEY=minioadmin
    command: ["/opt/spark/sbin/start-worker.sh", "spark://spark-master:7077"]
    depends_on:
      - spark-master
    ports:
      - "8082:8081"   # Web UI второго воркера (host 8082)
    volumes:
      - ./spark/spark-defaults.conf:/opt/spark/conf/spark-defaults.conf:ro
  minio:
    image: minio/minio:RELEASE.2024-10-02T17-50-41Z
    container_name: minio
    hostname: minio
    networks:
      - spark-net
    command: server /data --console-address ":9001"
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin
    ports:
      - "9000:9000"
      - "9001:9001"
    volumes:
      - minio-data:/data
  minio-init:
    image: minio/mc:RELEASE.2024-06-24T19-40-33Z-cpuv1
    container_name: minio-init
    hostname: minio-init
    networks:
      - spark-net
    depends_on:
      - minio
    entrypoint: >
      /bin/sh -c "
      echo 'Waiting for MinIO...';
      until mc alias set minio http://minio:9000 minioadmin minioadmin 2>/dev/null; do
        sleep 1;
      done;
      echo 'MinIO is up, creating bucket...';
      mc mb -p minio/lakehouse || true;
      echo 'Bucket lakehouse is ready';
      exit 0;
      "
  jupyter:
    build:
      context: ./jupyter
      args:
        NB_UID: ${NB_UID:-1000}
        NB_GID: ${NB_GID:-100}
    # image: jupyter-spark-iceberg:3.5.1
    container_name: jupyter
    hostname: jupyter
    depends_on:
      - spark-master
      - minio
    networks:
      - spark-net
    environment:
      - AWS_ACCESS_KEY_ID=minioadmin
      - AWS_SECRET_ACCESS_KEY=minioadmin
      - PYTHONPATH=/opt/src
    ports:
      - "8888:8888"
    volumes:
      - ./spark/spark-defaults.conf:/opt/spark/conf/spark-defaults.conf:ro
      - ./notebooks:/opt/work
      - ./src:/opt/src:ro
  trino:
    image: trinodb/trino:478
    container_name: trino
    hostname: trino
    networks:
      - spark-net
    depends_on:
      - minio
      - postgres
      - iceberg-catalog-init
    environment:
      - AWS_ACCESS_KEY_ID=minioadmin
      - AWS_SECRET_ACCESS_KEY=minioadmin
      - AWS_REGION=us-east-1
    ports:
      - "8090:8080"   # Web UI Trino
    volumes:
      - ./trino/catalog:/etc/trino/catalog:ro
 networks:
  spark-net:
 volumes:
  postgres-data:
  minio-data:
@@ -0,0 +1,27 @@
 # Берем за основу контейнер, приготовленный для spark в spark/Dockerfile
 FROM de-spark-iceberg:3.5.1
 USER root
 ENV DEBIAN_FRONTEND=noninteractive
 # Только JupyterLab, без дополнительных пакетов
 RUN pip3 install --no-cache-dir "jupyterlab==4.2.5"
 # Создаём непривилегированного пользователя
 ARG NB_USER=jovyan
 ARG NB_UID=1000
 RUN useradd --uid ${NB_UID} -m -s /bin/bash ${NB_USER} \
 && mkdir -p /opt/work \
 && chown -R ${NB_UID}:${NB_UID} /opt/work
 USER ${NB_UID}
 WORKDIR /opt/work
 EXPOSE 8888
 CMD ["jupyter", "lab", \
     "--ip=0.0.0.0", \
     "--port=8888", \
     "--no-browser", \
     "--NotebookApp.token=", \
     "--NotebookApp.password="]
@@ -0,0 +1,163 @@
 {
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лаба 3: партиционирование и эволюция схемы",
    "",
    "В этом ноутбуке мы посмотрим, как Iceberg работает с партиционированными таблицами и эволюцией схемы поверх общего каталога `lakehouse`.",
    "",
    "Перед началом убедись, что стенд запущен (`docker compose up -d`) и Spark-кластер доступен."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import SparkSession",
    "",
    "spark = (",
    "    SparkSession.builder",
    "    .appName(\"lab3-partitioning-schema-evolution\")",
    "    .master(\"spark://spark-master:7077\")",
    "    .getOrCreate()",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 1. Партиционированная таблица",
    "",
    "Для начала создадим партиционированную Iceberg-таблицу `lakehouse.default.partition_demo` с помощью готового SQL-скрипта из `src/spark/partitioned_table_demo.sql`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path",
    "",
    "sql_path = Path(\"/opt/src/spark/partitioned_table_demo.sql\")",
    "sql_text = sql_path.read_text(encoding=\"utf-8\")",
    "",
    "for statement in sql_text.split(\";\"):",
    "    stmt = statement.strip()",
    "    if stmt:",
    "        spark.sql(stmt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, какие данные записаны по датам, и обсудим партиционирование по `event_date`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark.sql(\"\"\"",
    "SELECT",
    "  event_date,",
    "  COUNT(*) AS cnt,",
    "  SUM(amount) AS total_amount",
    "FROM lakehouse.default.partition_demo",
    "GROUP BY event_date",
    "ORDER BY event_date",
    "\"\"\").show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark.sql(\"\"\"",
    "SELECT *",
    "FROM lakehouse.default.partition_demo",
    "WHERE event_date = DATE '2024-01-01'",
    "ORDER BY user_id",
    "\"\"\").show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 2. Эволюция схемы",
    "",
    "Теперь посмотрим на эволюцию схемы: создадим таблицу, добавим колонку и вставим новые строки с дополнительными данными.",
    "",
    "Для подготовки таблицы используем скрипт `src/spark/schema_evolution_demo.sql`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sql_path = Path(\"/opt/src/spark/schema_evolution_demo.sql\")",
    "sql_text = sql_path.read_text(encoding=\"utf-8\")",
    "",
    "for statement in sql_text.split(\";\"):",
    "    stmt = statement.strip()",
    "    if stmt:",
    "        spark.sql(stmt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark.sql(\"DESCRIBE TABLE lakehouse.default.schema_evolution_demo\").show(truncate=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark.sql(\"\"\"",
    "SELECT *",
    "FROM lakehouse.default.schema_evolution_demo",
    "ORDER BY id",
    "\"\"\").show(truncate=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обрати внимание, что старые строки имеют `NULL` в колонке `metadata`, а новые — заполненное значение.",
    "Iceberg хранит историю снапшотов и позволяет эволюцию схемы без сложных миграций."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
 }
@@ -0,0 +1,86 @@
 {
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ca5e5822-18cb-405e-90f3-a0f2f8ad2260",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Setting default log level to \"WARN\".\n",
      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n",
      "25/12/03 09:08:48 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n",
      "25/12/03 09:08:52 WARN MetricsConfig: Cannot locate configuration: tried hadoop-metrics2-s3a-file-system.properties,hadoop-metrics2.properties\n",
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+---+\n",
      "| id|txt|\n",
      "+---+---+\n",
      "|  1| ok|\n",
      "+---+---+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "\n",
    "spark = (\n",
    "    SparkSession.builder\n",
    "    .appName(\"check\")\n",
    "    .master(\"spark://spark-master:7077\")\n",
    "    .getOrCreate()\n",
    ")\n",
    "\n",
    "spark.sql(\"\"\"\n",
    "    CREATE TABLE IF NOT EXISTS lakehouse.default.demo_fix (\n",
    "        id BIGINT,\n",
    "        txt STRING\n",
    "    )\n",
    "    USING iceberg\n",
    "\"\"\")\n",
    "\n",
    "spark.sql(\"INSERT INTO lakehouse.default.demo_fix VALUES (1, 'ok')\")\n",
    "\n",
    "spark.sql(\"SELECT * FROM lakehouse.default.demo_fix\").show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e125075-feab-4974-baa2-f787e41b46fd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
 }
@@ -0,0 +1,47 @@
 FROM spark:3.5.1-scala2.12-java17-python3-ubuntu
 USER root
 ENV DEBIAN_FRONTEND=noninteractive
 # Версии зависимостей в одном месте
 ARG HADOOP_AWS_VERSION=3.3.4
 ARG AWS_SDK_VERSION=1.12.262
 ARG ICEBERG_VERSION=1.10.0
 ARG POSTGRES_VERSION=42.7.3
 ARG PYSPARK_VERSION=3.5.1
 # Базовый Python/утилиты
 RUN apt-get update \
 && apt-get install -y python3-pip curl wget nano mc tmux\
 && rm -rf /var/lib/apt/lists/*
 # JAR'ы для S3A и Iceberg
 RUN mkdir -p /opt/spark/jars \
 && curl -L "https://repo1.maven.org/maven2/org/apache/hadoop/hadoop-aws/${HADOOP_AWS_VERSION}/hadoop-aws-${HADOOP_AWS_VERSION}.jar" \
      -o "/opt/spark/jars/hadoop-aws-${HADOOP_AWS_VERSION}.jar" \
 && curl -L "https://repo1.maven.org/maven2/com/amazonaws/aws-java-sdk-bundle/${AWS_SDK_VERSION}/aws-java-sdk-bundle-${AWS_SDK_VERSION}.jar" \
      -o "/opt/spark/jars/aws-java-sdk-bundle-${AWS_SDK_VERSION}.jar" \
 && curl -L "https://repo1.maven.org/maven2/org/apache/iceberg/iceberg-spark-runtime-3.5_2.12/${ICEBERG_VERSION}/iceberg-spark-runtime-3.5_2.12-${ICEBERG_VERSION}.jar" \
      -o "/opt/spark/jars/iceberg-spark-runtime-3.5_2.12-${ICEBERG_VERSION}.jar" \
 && curl -L "https://repo1.maven.org/maven2/org/postgresql/postgresql/${POSTGRES_VERSION}/postgresql-${POSTGRES_VERSION}.jar" \
      -o "/opt/spark/jars/postgresql-${POSTGRES_VERSION}.jar"
 # Общие Python-пакеты для драйвера и executors
 RUN pip3 install --no-cache-dir \
      "pyspark==${PYSPARK_VERSION}" \
      pandas \
      numpy \
      pyarrow
 ENV PYSPARK_PYTHON=python3
 ENV PYSPARK_DRIVER_PYTHON=python3
 # Конфиг Spark (S3 + Iceberg + каталог lakehouse)
 RUN mkdir -p /opt/spark/conf
 # Конфиги подключим уже в docker-compose
 # COPY spark-defaults.conf /opt/spark/conf/spark-defaults.conf
 # Возвращаемся к непривилегированному UID как в официальном образе
 # (комментарий отдельно, чтобы не ломать USER)
 # тот же пользователь, что в официальном spark-образе
 USER 185
@@ -0,0 +1,26 @@
 # spark/spark-defaults.conf
 # Включаем Iceberg extensions
 spark.sql.extensions                             org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
 # JDBC-каталог "lakehouse" (метаданные в Postgres, данные в MinIO)
 spark.sql.catalog.lakehouse                      org.apache.iceberg.spark.SparkCatalog
 spark.sql.catalog.lakehouse.catalog-impl         org.apache.iceberg.jdbc.JdbcCatalog
 spark.sql.catalog.lakehouse.uri                  jdbc:postgresql://postgres-iceberg:5432/iceberg
 spark.sql.catalog.lakehouse.jdbc.user            iceberg
 spark.sql.catalog.lakehouse.jdbc.password        iceberg
 spark.sql.catalog.lakehouse.jdbc.driver          org.postgresql.Driver
 spark.sql.catalog.lakehouse.warehouse            s3a://lakehouse/warehouse
 # Настройки S3A для MinIO
 spark.hadoop.fs.s3a.impl                         org.apache.hadoop.fs.s3a.S3AFileSystem
 spark.hadoop.fs.s3a.endpoint                     http://minio:9000
 spark.hadoop.fs.s3a.path.style.access            true
 spark.hadoop.fs.s3a.connection.ssl.enabled       false
 # Креды MinIO (для учебного стенда ок в явном виде)
 spark.hadoop.fs.s3a.access.key                   minioadmin
 spark.hadoop.fs.s3a.secret.key                   minioadmin
 # Чуть-чуть логики по умолчанию
 spark.sql.catalog.lakehouse.default-namespace    default
@@ -0,0 +1,12 @@
 from pyspark.sql import SparkSession
 spark = (
    SparkSession.builder
    .appName("test-cluster")
    .master("spark://spark-master:7077")  # важно: не local[*]
    .getOrCreate()
 )
 spark.range(0, 1000000).groupBy().sum().show()
 spark.stop()
@@ -0,0 +1,10 @@
 -- создаём таблицу в каталоге lakehouse, в MinIO
 CREATE TABLE lakehouse.default.demo_tbl (
  id BIGINT,
  txt STRING
 )
 USING iceberg;
 INSERT INTO lakehouse.default.demo_tbl VALUES (1, 'hello'), (2, 'world');
 SELECT * FROM lakehouse.default.demo_tbl;
@@ -0,0 +1,24 @@
 #!/usr/bin/env python3
 from pyspark.sql import SparkSession
 TABLE = "lakehouse.default.spark_trino_smoke"
 def main() -> None:
    spark = SparkSession.builder.appName("iceberg-smoke").getOrCreate()
    spark.sql("CREATE NAMESPACE IF NOT EXISTS lakehouse.default")
    spark.sql(f"DROP TABLE IF EXISTS {TABLE}")
    spark.sql(f"CREATE TABLE {TABLE} (id INT, payload STRING) USING iceberg")
    spark.sql(f"INSERT INTO {TABLE} VALUES (1, 'from_spark')")
    result = spark.sql(f"SELECT * FROM {TABLE} ORDER BY id")
    result.show(truncate=False)
    print(f"✔ Spark записал и прочитал таблицу {TABLE}")
    spark.stop()
 if __name__ == "__main__":
    main()
@@ -0,0 +1,20 @@
 -- Партиционированная Iceberg-таблица lakehouse.default.partition_demo
 CREATE NAMESPACE IF NOT EXISTS lakehouse.default;
 DROP TABLE IF EXISTS lakehouse.default.partition_demo;
 CREATE TABLE lakehouse.default.partition_demo (
  user_id    BIGINT,
  event_date DATE,
  amount     DOUBLE
 )
 USING iceberg
 PARTITIONED BY (event_date);
 INSERT INTO lakehouse.default.partition_demo VALUES
  (1, '2024-01-01', 10.0),
  (2, '2024-01-01', 20.0),
  (3, '2024-02-01', 30.0),
  (4, '2024-02-01', 40.0);
@@ -0,0 +1,23 @@
 -- Эволюция схемы Iceberg-таблицы lakehouse.default.schema_evolution_demo
 CREATE NAMESPACE IF NOT EXISTS lakehouse.default;
 DROP TABLE IF EXISTS lakehouse.default.schema_evolution_demo;
 CREATE TABLE lakehouse.default.schema_evolution_demo (
  id    BIGINT,
  value STRING
 )
 USING iceberg;
 INSERT INTO lakehouse.default.schema_evolution_demo VALUES
  (1, 'old_row_1'),
  (2, 'old_row_2');
 ALTER TABLE lakehouse.default.schema_evolution_demo
  ADD COLUMN metadata STRING;
 INSERT INTO lakehouse.default.schema_evolution_demo VALUES
  (3, 'new_row_1', 'extra_info'),
  (4, 'new_row_2', 'extra_info');
@@ -0,0 +1,5 @@
 -- Проверка чтения данных, созданных в Spark
 USE lakehouse.default;
 SHOW TABLES;
 SELECT * FROM spark_trino_smoke;
@@ -0,0 +1,13 @@
 -- Проверка эволюции схемы в Trino для таблицы,
 -- созданной в Spark (lakehouse.default.schema_evolution_demo).
 USE lakehouse.default;
 SHOW TABLES LIKE 'schema_evolution_demo';
 DESCRIBE schema_evolution_demo;
 SELECT *
 FROM schema_evolution_demo
 ORDER BY id;
@@ -0,0 +1,31 @@
 connector.name=iceberg
 # 1. Тип каталога — JDBC (метаданные в Postgres)
 iceberg.catalog.type=jdbc
 # Подключение к Postgres с метаданными Iceberg
 iceberg.jdbc-catalog.connection-url=jdbc:postgresql://postgres-iceberg:5432/iceberg
 iceberg.jdbc-catalog.connection-user=iceberg
 iceberg.jdbc-catalog.connection-password=iceberg
 # Обязательные поля JDBC-каталога
 iceberg.jdbc-catalog.driver-class=org.postgresql.Driver
 iceberg.jdbc-catalog.catalog-name=lakehouse
 iceberg.jdbc-catalog.schema-version=V1
 # 2. Warehouse целиком в S3 (MinIO)
 # Здесь "lakehouse" — имя S3-бакета, "warehouse" — префикс внутри него.
 iceberg.jdbc-catalog.default-warehouse-dir=s3://lakehouse/warehouse
 # 3. Включаем новый native S3 filesystem
 fs.hadoop.enabled=false
 fs.native-s3.enabled=true
 # 4. Настройки доступа к MinIO
 s3.endpoint=http://minio:9000
 s3.region=us-east-1
 s3.path-style-access=true
 # Статические ключи для MinIO (учебный стенд)
 s3.aws-access-key=minioadmin
 s3.aws-secret-key=minioadmin