ClickHouse 25.8 New Features Lab

---

A hands-on laboratory for learning and testing ClickHouse 25.8 new features (released 2025-08-28). This directory is designed for practical exercises with integrated MinIO-based Data Lake environment.

📋 Overview

ClickHouse 25.8 includes a new Parquet Reader (1.81x faster), enhanced Data Lake integration, Hive-style partitioning, S3 temporary data storage, and improved UNION ALL functionality.

🎯 Key Features

1. New Parquet Reader - 1.81x faster performance, 99.98% less data scanning
2. MinIO Integration - Data Lake implementation via S3-compatible storage
3. Data Lake Enhancements - Iceberg CREATE/DROP, Delta Lake writes, time travel
4. Hive-Style Partitioning - partition_strategy parameter, directory-based partitioning
5. Temporary Data on S3 - Use S3 instead of local disk for temporary data storage
6. Enhanced UNION ALL - _table virtual column support

🚀 Quick Start

Prerequisites

• macOS (with Docker Desktop)
• oss-docker environment setup
• datalake-minio-catalog auto-deployment (handled by setup script)

Setup and Run

# 1. Install ClickHouse 25.8 + MinIO Data Lake and start
cd local/releases/25.8
./00-setup.sh   # Deploys ClickHouse 25.8, MinIO, and Nessie

# 2. Run tests for each feature
./01-new-parquet-reader.sh      # Local file-based Parquet Reader test
./06-minio-integration.sh       # MinIO S3 integration test (★ Recommended)
./02-hive-partitioning.sh
./03-temp-data-s3.sh
./04-union-all-table.sh
./05-data-lake-features.sh

What Gets Deployed

When running ./00-setup.sh, the following are automatically deployed:

1. MinIO (ports 19000, 19001) - S3-compatible object storage - Web console: http://localhost:19001 - Credentials: admin / password123

2. Nessie (port 19120) - Git-like data catalog - REST API: http://localhost:19120

3. ClickHouse 25.8 (ports 2508, 25081) - Web UI: http://localhost:8123/play - TCP port: 25081

Manual Execution (SQL only)

To execute SQL files directly:

# Connect to ClickHouse client
cd ../../oss-docker
./client.sh 8123

# Execute SQL file
cd ../releases/25.8
source 01-new-parquet-reader.sql

📚 Feature Details

0. MinIO Integration (06-minio-integration) ★ Recommended

New Feature: Real-world Data Lake implementation with ClickHouse 25.8 + MinIO S3-compatible storage

Test Content: - Generate 50,000 e-commerce order data - Export data to MinIO in Parquet format - Read data from MinIO using S3 functions - Column pruning optimization (99.98% less data scanning) - Split files by country and wildcard queries - Daily revenue analysis (14 days) - Product category performance analysis - Customer segmentation analysis (VIP, Premium)

Execute:

./06-minio-integration.sh

Key Learning Points: - Integration of S3-compatible storage (MinIO) with ClickHouse - Data read/write via s3() function - Real-world performance of new Parquet Reader (1.81x faster) - Minimal data scanning through column pruning - Multi-file queries using wildcards - Data Lake implementation in local development environment

Real-World Use Cases: - Local Data Lake development and testing - Local validation before S3 migration - Cost-effective data storage - Data analytics pipeline prototyping - E-commerce revenue analysis dashboard - Customer behavior analysis and segmentation

Dataset: - 50,000 orders (8 countries, 5,000 customers) - 8 product categories - 4 order statuses - 38M+ total revenue

---

1. New Parquet Reader (01-new-parquet-reader)

New Feature: New Parquet Reader with 1.81x faster performance and 99.98% less data scanning

Test Content: - E-commerce event dataset generation (100,000 rows) - Parquet file export - Reading with new Parquet Reader - Column pruning optimization (read only necessary columns) - Complex analytical query performance - Conversion funnel analysis - User behavior analysis - Device and channel performance analysis - Geographic analysis - Product category performance - Time-based activity patterns

Execute:

./01-new-parquet-reader.sh
# Or
cat 01-new-parquet-reader.sql | docker exec -i clickhouse-25-8 clickhouse-client --multiline --multiquery

Key Learning Points: - New Parquet Reader is 1.81x faster than previous version - Column pruning scans 99.98% less data - Improved memory efficiency by reading only necessary columns - Full support for Parquet v2 format - Reduced memory usage for large Parquet files - Improved support for nested structures and arrays

Real-World Use Cases: - Data Lake query acceleration - Direct analysis of Parquet files on S3/GCS/Azure - ETL pipeline optimization - Large-scale log file analysis - Data warehouse federated queries - Machine learning feature engineering - Real-time analytics dashboards - Cost-effective cold storage queries

Performance Comparison: | Task | Previous Version | ClickHouse 25.8 | Improvement | |------|-----------------|-----------------|-------------| | Full Parquet scan | Baseline | 1.81x faster | 81% improvement | | Selective column read | Scans much data | 99.98% less scan | Scans only 0.02% | | Memory usage | High | Significantly reduced | Improved efficiency |

---

2. Hive-Style Partitioning (02-hive-partitioning)

New Feature: Hive-style directory structure support with partition_strategy parameter

Test Content: - Sales transaction data generation (100,000 rows) - Export data with Hive-style partitioning (year=YYYY/month=MM/) - Read partitioned data - Partition pruning (scan only specific partitions) - Regional sales analysis - Product category performance - Store performance ranking - Payment method analysis - Daily sales trends - High-value customer analysis - Partition efficiency comparison - Monthly growth rate analysis

Execute:

./02-hive-partitioning.sh

Key Learning Points: - Hive partitioning: key=value directory structure - Avoid unnecessary directory scans with partition pruning - Standard approach compatible with Spark, Presto, Athena - Multi-level partitioning support (year/month/day) - Automatic partition column detection - Add partitions without schema changes - Data organization and query optimization

Real-World Use Cases: - Data Lake organization (S3, HDFS, GCS) - Multi-engine data sharing (Spark + ClickHouse) - Time-series data management - Geographic data partitioning - Multi-tenant data isolation - ETL pipeline optimization - Compliance data retention - Cost-effective data archiving

Partition Pattern Examples:

/data/year=2024/month=12/day=01/
/data/country=US/region=West/
/data/tenant_id=123/date=2024-12-01/
/data/event_type=purchase/hour=14/

Performance Benefits: - Reduced I/O: Skip irrelevant partitions - Query speed: Read only necessary data - Organization: Intuitive directory structure - Scalability: Efficiently handle petabyte-scale data

---

3. Temporary Data on S3 (03-temp-data-s3)

New Feature: Use S3 instead of local disk for temporary data storage

Test Content: - Understanding temporary data concept - S3 temporary data configuration methods - Large dataset generation (500,000 events) - Large JOIN operations (using temporary storage) - High cardinality GROUP BY aggregation - Large-scale DISTINCT operations - Complex window functions - Large-scale ORDER BY sorting - Session analysis (complex queries) - Product performance analysis (multi-JOIN) - User cohort analysis

Execute:

./03-temp-data-s3.sh

Key Learning Points: - Temporary data is generated during query execution (JOIN, GROUP BY, ORDER BY, etc.) - Before 25.8: Local disk only, space constraints - After 25.8: S3 available, unlimited capacity - Automatic spillover when memory exceeds - Transparent operation to queries - S3-optimized I/O patterns - Automatic temporary data cleanup

Operations Requiring Temporary Data: 1. Large JOINs (hash tables) 2. High cardinality GROUP BY 3. Large data sorting (ORDER BY) 4. Window functions 5. DISTINCT operations 6. Aggregations exceeding memory limits

Configuration Example:

<storage_configuration>
    <disks>
        <s3_disk>
            <type>s3</type>
            <endpoint>https://bucket.s3.amazonaws.com/temp/</endpoint>
        </s3_disk>
    </disks>
</storage_configuration>

SET max_bytes_before_external_group_by = 10000000000;  -- 10GB
SET max_bytes_before_external_sort = 10000000000;       -- 10GB
SET temporary_data_policy = 'temp_policy';

Real-World Use Cases: - Ad-hoc analysis of large datasets - Complex multi-table JOINs - High cardinality aggregations - Data exploration and discovery - Machine learning feature engineering - Full dataset quality checks - Overcome local disk constraints - Cost-effective large-scale processing

Benefits: - Can exceed local disk limits - Better resource utilization - Cost efficiency (S3 cheaper than local SSD) - No manual temporary data management - Improved query success rate

---

4. Enhanced UNION ALL with _table Virtual Column (04-union-all-table)

New Feature: _table virtual column for source table identification in UNION ALL

Test Content: - Create multi-region sales tables (US, EU, Asia, LATAM) - Insert regional sales data - Use UNION ALL with _table column - Global sales analysis - Regional daily sales trends - Regional product performance - Customer distribution analysis - Filter by source table - Cross-region performance comparison - Weekly trend analysis - Data lineage tracking - Multi-currency aggregation

Execute:

./04-union-all-table.sh

Key Learning Points: - _table virtual column identifies source table in UNION ALL results - Can use _table in WHERE, GROUP BY, ORDER BY - Enable data lineage tracking - Source-based aggregation and filtering - Multi-table query audit trails - Minimal overhead

Syntax Examples:

SELECT *, 'table1' AS _table FROM table1
UNION ALL
SELECT *, 'table2' AS _table FROM table2

-- Filter by _table
WHERE _table = 'table1'

-- Group by _table
GROUP BY _table

-- Order by _table
ORDER BY _table, revenue DESC

Real-World Use Cases: - Multi-region data integration - Year-based table union (historical data) - Multi-tenant data queries - Federated query results - Data migration validation - Cross-shard analysis - Audit and compliance - Data governance

Key Benefits: - Data lineage tracking - Source identification in merged results - Filter by source table - Source-based aggregation - Multi-table query audit trails - Debugging and troubleshooting

---

5. Data Lake Enhancements (05-data-lake-features)

New Feature: Iceberg CREATE/DROP, Delta Lake writes, time travel

Test Content: - Data Lake overview and feature description - Product catalog data generation (10,000 products) - Export to Data Lake in Parquet format - Read data from Data Lake - Version management simulation (v1, v2, v3) - Time travel - version comparison - Delta Lake style incremental updates - Iceberg style partitioning - Schema evolution simulation - Multi-version queries - Data Lake metadata queries - Point-in-time queries - Version-based audit trails

Execute:

./05-data-lake-features.sh

Key Learning Points: - Apache Iceberg table CREATE/DROP - Delta Lake write support - ACID transaction guarantees - Schema evolution (without rewriting) - Query historical versions with time travel - Version comparison and auditing - Metadata optimization - Multi-format integration (Parquet, Iceberg, Delta)

Time Travel Examples:

-- Iceberg: Point-in-time query
SELECT * FROM iceberg_table
FOR SYSTEM_TIME AS OF '2024-12-01';

-- Delta Lake: Specific version query
SELECT * FROM delta_table
VERSION AS OF 42;

-- Timestamp-based query
SELECT * FROM delta_table
TIMESTAMP AS OF '2024-12-01 00:00:00';

Real-World Use Cases: - Data Lake analytics - Direct S3/HDFS queries - Multi-format support - Partition pruning

• Data engineering:
• ETL pipelines
• Data quality checks

• Schema evolution

• Data science:

• Feature engineering
• Historical analysis

• Experiment tracking

• Compliance and auditing:

• Regulatory compliance with time travel
• Audit trails

• Data lineage

• Real-time analytics:

• Streaming + batch
• Incremental updates
• ACID guarantees

Integration Examples: - ClickHouse + Spark: Share Iceberg tables - ClickHouse + Presto: Federated queries - ClickHouse + Airflow: ETL orchestration - ClickHouse + dbt: Data transformation - ClickHouse + Kafka: Streaming ingestion

Performance Tips: - Use partitioning for large datasets - Leverage time travel for debugging - Implement schema evolution carefully - Monitor metadata operations - Optimize partition strategy - Improve storage efficiency with compression - Optimize file size (128MB-1GB)

🔧 Management

ClickHouse Connection Info

• Web UI: http://localhost:8123/play
• HTTP API: http://localhost:8123
• TCP: localhost:9000
• User: default (no password)

Useful Commands

# Check ClickHouse status
cd ../../oss-docker
./status.sh

# Connect to CLI
./client.sh 8123

# View logs
docker logs clickhouse-25-8

# Stop
./stop.sh

# Complete removal
./stop.sh --cleanup

📂 File Structure

25.8/
├── README.md                      # This document
├── 00-setup.sh                    # ClickHouse 25.8 installation script
├── 01-new-parquet-reader.sh       # New Parquet Reader test execution
├── 01-new-parquet-reader.sql      # New Parquet Reader SQL
├── 02-hive-partitioning.sh        # Hive-style partitioning test execution
├── 02-hive-partitioning.sql       # Hive-style partitioning SQL
├── 03-temp-data-s3.sh             # S3 temporary data test execution
├── 03-temp-data-s3.sql            # S3 temporary data SQL
├── 04-union-all-table.sh          # UNION ALL test execution
├── 04-union-all-table.sql         # UNION ALL SQL
├── 05-data-lake-features.sh       # Data Lake features test execution
├── 05-data-lake-features.sql      # Data Lake features SQL
├── 06-minio-integration.sh        # MinIO integration test execution
└── 06-minio-integration.sql       # MinIO integration SQL

🎓 Learning Path

For Beginners

1. 00-setup.sh - Understand environment setup
2. 01-new-parquet-reader - Learn Parquet file reading and performance improvements
3. 04-union-all-table - Basics of multi-table integration

For Intermediate Users

1. 02-hive-partitioning - Understand partitioning strategies
2. 03-temp-data-s3 - Learn large-scale query optimization
3. 05-data-lake-features - Explore Data Lake integration

For Advanced Users

• Combine all features to implement end-to-end Data Lake pipelines
• Design real production scenarios
• Performance benchmarking and optimization
• Multi-engine integration (Spark, Presto, ClickHouse)

💡 Feature Comparison

ClickHouse 25.8 vs Previous Versions

Feature	Before 25.8	ClickHouse 25.8	Improvement
Parquet Reader	Standard	1.81x faster	81% faster
Parquet Column Pruning	Basic	99.98% less scan	Drastically reduced I/O
Hive Partitioning	Manual	Native support	Standard compatibility
Temporary Data	Local disk only	S3 support	Unlimited capacity
UNION ALL	Basic	_table column	Source tracking
Iceberg Tables	Read-only	CREATE/DROP	Full management
Delta Lake	Read-only	Write support	Bidirectional
Time Travel	Limited	Full support	Historical queries

Performance Comparison

Operation	Previous	ClickHouse 25.8	Benefit
Parquet full scan	Baseline	1.81x faster	Speed
Parquet selective columns	Many bytes	0.02% of data	I/O efficiency
Hive partition query	Full scan	Partition pruning	Reduced scanning
Large JOIN	Memory limited	S3 spillover	Unlimited capacity
Multi-table union	No tracking	Source identification	Data lineage
Data Lake writes	Limited	Full ACID	Data integrity

🆕 What's New in 25.8

• _table virtual column on every table — not just Merge tables (#63665)
• Hive-style partitioned writes — plus a refactored read implementation (#76802)
• Iceberg writes — create operations, Glue and REST catalogs (#83983)
• DeltaLake write support — write to Delta tables (#85564)
• PromQL dialect — basic rate, delta and increase support (#75036)
• ArrowFlight RPC — new arrowflight() table function (#74184)
• PostgreSQL COPY — COPY command over the PostgreSQL protocol (#74344)
• Iceberg position deletes — merge-on-read deletes, merged by OPTIMIZE (#83094)
• JSONExtractCaseInsensitive — case-insensitive JSON key lookup (#83770)
• zookeeper_connection_log — historical ZooKeeper connections (#79494)
• CPU preemption scheduling — workload settings for CPU throttling (#80879)
• DESCRIBE SELECT — in addition to DESCRIBE (SELECT ...) (#82947)
• nowInBlock64() — block-level DateTime64 (#84178)
• dateTimeToUUIDv7() — derive a UUIDv7 from a DateTime (#84319)
• Hash output format — fingerprint a query result (#84607)
• S3 permission grants — GRANT READ ON S3('s3://foo/.*') (#84503)

🔍 Additional Resources

• Official Release Blog: ClickHouse 25.8 Release
• ClickHouse Documentation: docs.clickhouse.com
• Release Notes: Changelog 2025
• GitHub Repository: ClickHouse GitHub
• Data Lake Formats:
• Apache Iceberg
• Delta Lake
• Apache Parquet

📝 Notes

• All features verified on ClickHouse 25.8.28.1
• 06-minio-integration needs the companion MinIO stack and is not covered by that run
• Each script can be executed independently
• Read and modify SQL files directly to experiment
• Test data is generated within each SQL file
• Cleanup is commented out by default
• Thorough testing recommended before production use
• Data Lake features may require appropriate storage configuration

🔒 Security Considerations

When accessing Data Lake: - Manage S3/GCS/Azure credentials securely - Use environment variables or IAM roles - Data encryption (in transit and at rest) - Access control and permission management - Enable audit logging

When using temporary data: - S3 bucket access control - Set up automatic temporary data cleanup - Cost monitoring - Consider network bandwidth

⚡ Performance Tips

Parquet Reader optimization: - SELECT only necessary columns - Filter rows with WHERE conditions - Maintain appropriate file size (128MB-1GB) - Choose compression algorithm (Snappy, ZSTD)

Hive Partitioning optimization: - Choose partition keys matching query patterns - Maintain appropriate partition count (not too many or too few) - Include partition keys in WHERE conditions - Leverage partition pruning

Temporary data optimization: - Set appropriate memory thresholds - Perform large operations during off-peak hours - Monitor S3 usage costs - Leverage local cache

UNION ALL optimization: - Partition pruning with _table column - Exclude unnecessary tables - Leverage index keys

Data Lake optimization: - Partition time-series data by date - Leverage metadata caching - Optimize file size - Utilize predicate pushdown

🚀 Production Deployment

Best Practices

-- Check partition information
SELECT
    partition,
    name,
    rows,
    bytes_on_disk
FROM system.parts
WHERE table = 'your_table'
  AND active = 1;

-- Monitor running queries
SELECT
    query_id,
    user,
    query,
    elapsed,
    memory_usage
FROM system.processes
WHERE query NOT LIKE '%system.processes%';

-- Check disk usage
SELECT
    name,
    path,
    formatReadableSize(free_space) AS free,
    formatReadableSize(total_space) AS total
FROM system.disks;

🛠 Management Commands

ClickHouse Management

# Check ClickHouse status
cd ../../oss-docker
./status.sh

# Connect to ClickHouse CLI
./client.sh 8123

# Stop ClickHouse
./stop.sh

# Restart ClickHouse
./start.sh

Data Lake (MinIO + Nessie) Management

# Access MinIO web console
# In browser: http://localhost:19001
# Credentials: admin / password123

# Stop MinIO and Nessie
cd ../datalake-minio-catalog
docker-compose down

# Restart MinIO and Nessie
docker-compose up -d minio nessie minio-setup

# Complete MinIO data removal
docker-compose down -v

# Check container logs
docker-compose logs -f minio
docker-compose logs -f nessie

Full Environment Reconfiguration

# 1. Stop and clean all services
cd ../../oss-docker
./stop.sh

cd ../datalake-minio-catalog
docker-compose down -v

# 2. Full restart
cd ../releases/25.8
./00-setup.sh

Data Verification

# Check files stored in MinIO
docker exec -it minio mc ls myminio/warehouse/

# Check ClickHouse tables
docker exec -it clickhouse-25-8 clickhouse-client -q "SHOW TABLES"

# Check ClickHouse database size
docker exec -it clickhouse-25-8 clickhouse-client -q "SELECT database, formatReadableSize(sum(bytes)) as size FROM system.parts GROUP BY database"

Migration Strategy

1. Validate in test environment - Test all new features - Performance benchmarking - Establish rollback plan

2. Gradual rollout - Start with small datasets - Monitor and measure performance - Immediate response on issues

3. Monitoring - Track query performance - Monitor resource usage - Check errors and warnings

🤝 Contributing

If you have improvements or additional examples for this lab: 1. Register an issue 2. Submit a Pull Request 3. Share feedback

📄 License

MIT — free to learn from and modify.

---

Happy Learning! 🚀

For questions or issues, please refer to the main clickhouse-hols README.

---

# 1. ClickHouse 25.8 + MinIO Data Lake 설치 및 시작
cd local/releases/25.8
./00-setup.sh   # ClickHouse 25.8, MinIO, Nessie를 모두 배포합니다

# 2. 각 기능별 테스트 실행
./01-new-parquet-reader.sh      # 로컬 파일 기반 Parquet Reader 테스트
./06-minio-integration.sh       # MinIO S3 통합 테스트 (★ 추천)
./02-hive-partitioning.sh
./03-temp-data-s3.sh
./04-union-all-table.sh
./05-data-lake-features.sh

# ClickHouse 클라이언트 접속
cd ../../oss-docker
./client.sh 8123

# SQL 파일 실행
cd ../releases/25.8
source 01-new-parquet-reader.sql

./06-minio-integration.sh

./01-new-parquet-reader.sh
# 또는
cat 01-new-parquet-reader.sql | docker exec -i clickhouse-25-8 clickhouse-client --multiline --multiquery

./02-hive-partitioning.sh

/data/year=2024/month=12/day=01/
/data/country=US/region=West/
/data/tenant_id=123/date=2024-12-01/
/data/event_type=purchase/hour=14/

./03-temp-data-s3.sh

<storage_configuration>
    <disks>
        <s3_disk>
            <type>s3</type>
            <endpoint>https://bucket.s3.amazonaws.com/temp/</endpoint>
        </s3_disk>
    </disks>
</storage_configuration>

SET max_bytes_before_external_group_by = 10000000000;  -- 10GB
SET max_bytes_before_external_sort = 10000000000;       -- 10GB
SET temporary_data_policy = 'temp_policy';

./04-union-all-table.sh

SELECT *, 'table1' AS _table FROM table1
UNION ALL
SELECT *, 'table2' AS _table FROM table2

-- _table로 필터링
WHERE _table = 'table1'

-- _table로 그룹화
GROUP BY _table

-- _table로 정렬
ORDER BY _table, revenue DESC

./05-data-lake-features.sh

-- Iceberg: 특정 시점 쿼리
SELECT * FROM iceberg_table
FOR SYSTEM_TIME AS OF '2024-12-01';

-- Delta Lake: 특정 버전 쿼리
SELECT * FROM delta_table
VERSION AS OF 42;

-- 타임스탬프 기반 쿼리
SELECT * FROM delta_table
TIMESTAMP AS OF '2024-12-01 00:00:00';

# ClickHouse 상태 확인
cd ../../oss-docker
./status.sh

# CLI 접속
./client.sh 8123

# 로그 확인
docker logs clickhouse-25-8

# 중지
./stop.sh

# 완전 삭제
./stop.sh --cleanup

25.8/
├── README.md                      # 이 문서
├── 00-setup.sh                    # ClickHouse 25.8 설치 스크립트
├── 01-new-parquet-reader.sh       # New Parquet Reader 테스트 실행
├── 01-new-parquet-reader.sql      # New Parquet Reader SQL
├── 02-hive-partitioning.sh        # Hive-style 파티셔닝 테스트 실행
├── 02-hive-partitioning.sql       # Hive-style 파티셔닝 SQL
├── 03-temp-data-s3.sh             # S3 임시 데이터 테스트 실행
├── 03-temp-data-s3.sql            # S3 임시 데이터 SQL
├── 04-union-all-table.sh          # UNION ALL 테스트 실행
├── 04-union-all-table.sql         # UNION ALL SQL
├── 05-data-lake-features.sh       # Data Lake 기능 테스트 실행
├── 05-data-lake-features.sql      # Data Lake 기능 SQL
├── 06-minio-integration.sh        # MinIO 통합 테스트 실행
└── 06-minio-integration.sql       # MinIO 통합 SQL

-- 파티션 정보 확인
SELECT
    partition,
    name,
    rows,
    bytes_on_disk
FROM system.parts
WHERE table = 'your_table'
  AND active = 1;

-- 실행 중인 쿼리 모니터링
SELECT
    query_id,
    user,
    query,
    elapsed,
    memory_usage
FROM system.processes
WHERE query NOT LIKE '%system.processes%';

-- 디스크 사용량 확인
SELECT
    name,
    path,
    formatReadableSize(free_space) AS free,
    formatReadableSize(total_space) AS total
FROM system.disks;

# ClickHouse 상태 확인
cd ../../oss-docker
./status.sh

# ClickHouse CLI 접속
./client.sh 8123

# ClickHouse 중지
./stop.sh

# ClickHouse 재시작
./start.sh

# MinIO 웹 콘솔 접속
# 브라우저에서: http://localhost:19001
# 자격증명: admin / password123

# MinIO 및 Nessie 중지
cd ../datalake-minio-catalog
docker-compose down

# MinIO 및 Nessie 재시작
docker-compose up -d minio nessie minio-setup

# MinIO 데이터 완전 삭제
docker-compose down -v

# 컨테이너 로그 확인
docker-compose logs -f minio
docker-compose logs -f nessie

# 1. 모든 서비스 중지 및 정리
cd ../../oss-docker
./stop.sh

cd ../datalake-minio-catalog
docker-compose down -v

# 2. 전체 재시작
cd ../releases/25.8
./00-setup.sh

# MinIO에 저장된 파일 확인
docker exec -it minio mc ls myminio/warehouse/

# ClickHouse 테이블 확인
docker exec -it clickhouse-25-8 clickhouse-client -q "SHOW TABLES"

# ClickHouse 데이터베이스 크기 확인
docker exec -it clickhouse-25-8 clickhouse-client -q "SELECT database, formatReadableSize(sum(bytes)) as size FROM system.parts GROUP BY database"