benchbox 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

benchbox/platforms/adapter_factory.py

@@ -230,13 +230,13 @@ def _get_dataframe_adapter(platform: str, **config: Any) -> Any:
     )
 
     adapter_mapping = {
-        "polars": (PolarsDataFrameAdapter, POLARS_AVAILABLE, "uv add polars"),
-        "pandas": (PandasDataFrameAdapter, PANDAS_AVAILABLE, "uv add pandas"),
-        "modin": (ModinDataFrameAdapter, MODIN_AVAILABLE, "uv add modin[ray]"),
+        "polars": (PolarsDataFrameAdapter, POLARS_AVAILABLE, "pip install polars"),
+        "pandas": (PandasDataFrameAdapter, PANDAS_AVAILABLE, "pip install pandas"),
+        "modin": (ModinDataFrameAdapter, MODIN_AVAILABLE, "pip install modin[ray]"),
         "cudf": (CuDFDataFrameAdapter, CUDF_AVAILABLE, "pip install cudf-cu12"),
-        "dask": (DaskDataFrameAdapter, DASK_AVAILABLE, "uv add dask[distributed]"),
-        "pyspark": (PySparkDataFrameAdapter, PYSPARK_AVAILABLE, "uv add benchbox --extra dataframe-pyspark"),
-        "datafusion": (DataFusionDataFrameAdapter, DATAFUSION_DF_AVAILABLE, "uv add datafusion"),
+        "dask": (DaskDataFrameAdapter, DASK_AVAILABLE, "pip install dask[distributed]"),
+        "pyspark": (PySparkDataFrameAdapter, PYSPARK_AVAILABLE, "pip install pyspark"),
+        "datafusion": (DataFusionDataFrameAdapter, DATAFUSION_DF_AVAILABLE, "pip install datafusion"),
     }
 
     if platform not in adapter_mapping:

benchbox/platforms/azure_synapse.py

@@ -26,6 +26,7 @@ if TYPE_CHECKING:
     )
 
 from ..utils.dependencies import check_platform_dependencies, get_dependency_error_message
+from ..utils.file_format import get_delimiter_for_file
 from .base import PlatformAdapter
 
 # Azure Synapse uses T-SQL dialect (compatible with SQL Server)
@@ -541,11 +542,7 @@ class AzureSynapseAdapter(PlatformAdapter):
 
                 # Determine file format
                 first_file = valid_files[0]
-                file_str = str(first_file.name)
-                if ".tbl" in file_str or ".dat" in file_str:
-                    field_terminator = "|"
-                else:
-                    field_terminator = ","
+                field_terminator = get_delimiter_for_file(first_file)
 
                 # Use COPY INTO for loading
                 qualified_table = f"[{self.schema}].[{table_name}]"
@@ -609,8 +606,7 @@ class AzureSynapseAdapter(PlatformAdapter):
                 qualified_table = f"[{self.schema}].[{table_name}]"
 
                 for file_path in valid_files:
-                    file_str = str(file_path.name)
-                    delimiter = "|" if ".tbl" in file_str or ".dat" in file_str else ","
+                    delimiter = get_delimiter_for_file(file_path)
 
                     with open(file_path) as f:
                         batch_size = 1000

benchbox/platforms/base/adapter.py

@@ -37,6 +37,7 @@ from benchbox.core.constants import (
 )
 from benchbox.core.errors import PlanCaptureError, SerializationError
 from benchbox.core.operations import OperationExecutor
+from benchbox.core.results.builder import normalize_benchmark_id
 from benchbox.platforms.base.models import (
     ConnectionConfig,
     DataGenerationPhase,
@@ -1340,29 +1341,27 @@ class PlatformAdapter(VerbosityMixin, ABC):
         Returns:
             Benchmark type string (lowercase) or None if unknown
         """
-        # Try to get explicit _name attribute
+        # Try to get explicit _name attribute first
         if hasattr(benchmark, "_name"):
-            name = benchmark._name.lower()
-            # Normalize common patterns - extract just the benchmark identifier
-            if "tpc-h" in name or "tpch" in name:
-                return "tpch"
-            elif "tpc-ds" in name or "tpcds" in name:
-                return "tpcds"
-            # If it's a simple name without spaces, use it directly
-            if " " not in name:
-                return name
+            benchmark_id = normalize_benchmark_id(benchmark._name)
+            # normalize_benchmark_id returns the lowercase name for unknown benchmarks
+            # Check if it's a known benchmark or use as-is if simple
+            if benchmark_id in ("tpch", "tpcds", "ssb", "clickbench"):
+                return benchmark_id
+            # If the original name had no spaces, use it directly
+            if " " not in benchmark._name:
+                return benchmark._name.lower()
 
         # Fall back to class name analysis
         class_name = type(benchmark).__name__.lower()
-        if "tpch" in class_name:
-            return "tpch"
-        elif "tpcds" in class_name or "tpc_ds" in class_name:
-            return "tpcds"
-        elif "clickbench" in class_name:
-            return "clickbench"
-        elif "ssb" in class_name or "star_schema" in class_name:
-            return "ssb"
-        elif "amplab" in class_name:
+
+        # Use normalize_benchmark_id for TPC benchmarks
+        normalized = normalize_benchmark_id(class_name)
+        if normalized in ("tpch", "tpcds", "ssb", "clickbench"):
+            return normalized
+
+        # Handle other benchmark types by class name pattern
+        if "amplab" in class_name:
             return "amplab"
         elif "h2odb" in class_name or "h2o" in class_name:
             return "h2odb"
@@ -1372,14 +1371,14 @@ class PlatformAdapter(VerbosityMixin, ABC):
             return "joinorder"
         elif "tpcdi" in class_name or "tpc_di" in class_name:
             return "tpcdi"
+        elif "star_schema" in class_name:
+            return "ssb"
 
         # Check display_name if available
         if hasattr(benchmark, "display_name"):
-            display_name = str(benchmark.display_name).lower()
-            if "tpch" in display_name:
-                return "tpch"
-            elif "tpcds" in display_name or "tpc-ds" in display_name:
-                return "tpcds"
+            benchmark_id = normalize_benchmark_id(str(benchmark.display_name))
+            if benchmark_id in ("tpch", "tpcds", "ssb", "clickbench"):
+                return benchmark_id
 
         # Unknown benchmark type - validation will be skipped
         return None
@@ -2756,6 +2755,12 @@ class PlatformAdapter(VerbosityMixin, ABC):
 
             execution_type = run_config.get("test_execution_type", "standard")
 
+            # Extract cached power test metrics
+            power_at_size_value = 0.0
+            if getattr(self, "_last_power_test_result", None) is not None:
+                power_at_size_value = getattr(self._last_power_test_result, "power_at_size", 0.0) or 0.0
+                self._last_power_test_result = None
+
             power_test_phase = None
             if execution_type not in {"throughput"}:
                 power_test_phase = PowerTestPhase(
@@ -2764,7 +2769,7 @@ class PlatformAdapter(VerbosityMixin, ABC):
                     duration_ms=int(total_exec_time * 1000),
                     query_executions=query_executions,
                     geometric_mean_time=avg_time,
-                    power_at_size=0.0,  # Can be calculated later if needed
+                    power_at_size=power_at_size_value,
                 )
 
             throughput_test_phase = None
@@ -2808,6 +2813,22 @@ class PlatformAdapter(VerbosityMixin, ABC):
                 "connection_config_hash": self._hash_connection_config(run_config.get("connection", {})),
                 "python_version": platform.python_version(),
                 "benchbox_version": "0.1.0",
+                "mode": "sql",
+                "benchmark_id": run_config.get("benchmark") or run_config.get("benchmark_name"),
+                "run_config": {
+                    "compression": {
+                        "type": run_config.get("compression_type"),
+                        "level": run_config.get("compression_level"),
+                    }
+                    if run_config.get("compression_type")
+                    else None,
+                    "seed": run_config.get("seed"),
+                    "phases": run_config.get("phases"),
+                    "query_subset": run_config.get("query_subset"),
+                    "platform_options": run_config.get("platform_options"),
+                    "tuning_mode": run_config.get("tuning_mode"),
+                    "tuning_config": run_config.get("tuning_config"),
+                },
             }
 
             # Calculate additional metrics needed
@@ -2822,6 +2843,17 @@ class PlatformAdapter(VerbosityMixin, ABC):
                 total_rows_loaded=total_rows_loaded,
             )
 
+            # Extract TPC metrics from phases for result propagation
+            power_at_size = power_test_phase.power_at_size if power_test_phase else None
+            throughput_at_size = throughput_test_phase.throughput_at_size if throughput_test_phase else None
+
+            # Calculate composite metric if both power and throughput are available
+            import math
+
+            qph_at_size = None
+            if power_at_size and power_at_size > 0 and throughput_at_size and throughput_at_size > 0:
+                qph_at_size = math.sqrt(power_at_size * throughput_at_size)
+
             return benchmark.create_enhanced_benchmark_result(
                 platform=self.platform_name,
                 query_results=query_results,
@@ -2848,6 +2880,11 @@ class PlatformAdapter(VerbosityMixin, ABC):
                 anonymous_machine_id=anonymous_machine_id,
                 validation_status=self._determine_overall_validation_status(validation_phase),
                 validation_details=validation_phase.validation_details,
+                # TPC metrics
+                power_at_size=power_at_size,
+                throughput_at_size=throughput_at_size,
+                qph_at_size=qph_at_size,
+                test_execution_type=execution_type,
             )
 
         finally:
@@ -3384,8 +3421,15 @@ class PlatformAdapter(VerbosityMixin, ABC):
             connection = kwargs.pop("connection", None)
             if connection is None:
                 raise ValueError("TPC benchmarks require a connection object for throughput tests")
+
             # TPC-DS uses connection_factory pattern
-            connection_factory = kwargs.pop("connection_factory", lambda: connection)
+            # Create thread-safe cursor for concurrent stream execution
+            # See: https://duckdb.org/docs/stable/guides/python/multiple_threads
+            def _default_connection_factory():
+                stream_cursor = connection.cursor()
+                return stream_cursor
+
+            connection_factory = kwargs.pop("connection_factory", _default_connection_factory)
 
             # Inject platform's target dialect if not already specified
             if "dialect" not in kwargs:
@@ -3609,7 +3653,7 @@ class PlatformAdapter(VerbosityMixin, ABC):
         try:
             # Extract configuration
             scale_factor = run_config.get("scale_factor", 1.0)
-            seed = run_config.get("seed", 1)
+            seed = run_config.get("seed")
             validation_mode = run_config.get("validation_mode")  # Universal validation mode
             stream_id = run_config.get("stream_id", 0)
             query_subset = run_config.get("query_subset")
@@ -3648,7 +3692,22 @@ class PlatformAdapter(VerbosityMixin, ABC):
                     validation_mode=validation_mode,
                     query_subset=query_subset,
                 )
-                power_test.run()
+                power_test_result = power_test.run()
+                for query_result in power_test_result.query_results:
+                    platform_result = {
+                        "query_id": query_result["query_id"],
+                        "execution_time": query_result["execution_time"],
+                        "status": "SUCCESS" if query_result["success"] else "FAILED",
+                        "rows_returned": query_result.get("result_count", 0),
+                        "test_type": "power",
+                        "stream_id": query_result.get("stream_id", current_stream_id),
+                        "position": query_result.get("position", 0),
+                        "iteration": 0,
+                        "run_type": "warmup",
+                    }
+                    if not query_result["success"]:
+                        platform_result["error"] = query_result.get("error", "Unknown error")
+                    all_results.append(platform_result)
 
             # Measurement runs
             for i in range(iterations):
@@ -3670,6 +3729,9 @@ class PlatformAdapter(VerbosityMixin, ABC):
                 # Execute the power test
                 power_test_result = power_test.run()
 
+                # Cache the power test result for metric extraction
+                self._last_power_test_result = power_test_result
+
                 # Display results
                 if power_test_result.success:
                     success_rate = power_test_result.queries_successful / max(power_test_result.queries_executed, 1)
@@ -3698,6 +3760,7 @@ class PlatformAdapter(VerbosityMixin, ABC):
                         "stream_id": query_result.get("stream_id", current_stream_id),
                         "position": query_result.get("position", 0),
                         "iteration": i + 1,
+                        "run_type": "measurement",
                     }
                     if not query_result["success"]:
                         platform_result["error"] = query_result.get("error", "Unknown error")
@@ -3736,9 +3799,8 @@ class PlatformAdapter(VerbosityMixin, ABC):
                 - scale_factor: Benchmark scale factor
 
         Returns:
-            List of query results from all measurement iterations, with each result
-            tagged with iteration number and run_type='measurement'. Warmup results
-            are discarded.
+            List of query results from all warmup and measurement iterations, with each result
+            tagged with iteration number and run_type ("warmup" or "measurement").
         """
         from rich.console import Console
 
@@ -3757,11 +3819,15 @@ class PlatformAdapter(VerbosityMixin, ABC):
 
         all_measurement_results = []
 
-        # Warm-up runs (results discarded)
+        # Warm-up runs (results captured)
         for i in range(warm_up_iterations):
             console.print(f"[cyan]--- Warm-up Run {i + 1}/{warm_up_iterations} ---[/cyan]")
-            # Execute all queries once, discard results
-            _ = self._execute_all_queries(benchmark, connection, run_config)
+            warmup_results = self._execute_all_queries(benchmark, connection, run_config)
+            for result in warmup_results:
+                result["iteration"] = 0
+                result["stream_id"] = 0
+                result["run_type"] = "warmup"
+                all_measurement_results.append(result)
 
         # Measurement runs (results collected)
         for i in range(iterations):
@@ -3771,6 +3837,7 @@ class PlatformAdapter(VerbosityMixin, ABC):
             # Tag each result with iteration number and run type
             for result in iteration_results:
                 result["iteration"] = i + 1
+                result["stream_id"] = i + 1
                 result["run_type"] = "measurement"
 
             all_measurement_results.extend(iteration_results)
@@ -3821,7 +3888,10 @@ class PlatformAdapter(VerbosityMixin, ABC):
 
             # Create connection factory that wraps the platform adapter connection
             def connection_factory():
-                conn_wrapper = PlatformAdapterConnection(connection, self)
+                # Create thread-safe cursor for concurrent stream execution
+                # See: https://duckdb.org/docs/stable/guides/python/multiple_threads
+                stream_cursor = connection.cursor()
+                conn_wrapper = PlatformAdapterConnection(stream_cursor, self)
                 # Configure benchmark context for query validation
                 conn_wrapper.benchmark_type = "tpcds"
                 conn_wrapper.scale_factor = scale_factor
@@ -3844,7 +3914,22 @@ class PlatformAdapter(VerbosityMixin, ABC):
                     dialect=self.get_target_dialect(),
                     query_subset=query_subset,
                 )
-                power_test.run()  # Results discarded for warmup
+                power_test_result = power_test.run()
+                for query_result in power_test_result.query_results:
+                    platform_result = {
+                        "query_id": query_result["query_id"],
+                        "execution_time": query_result["execution_time"],
+                        "status": "SUCCESS" if query_result["success"] else "FAILED",
+                        "rows_returned": query_result.get("result_count", 0),
+                        "test_type": "power",
+                        "stream_id": query_result.get("stream_id", current_stream_id),
+                        "position": query_result.get("position", 0),
+                        "iteration": 0,
+                        "run_type": "warmup",
+                    }
+                    if not query_result["success"]:
+                        platform_result["error"] = query_result.get("error", "Unknown error")
+                    all_results.append(platform_result)
 
             # Measurement runs
             for i in range(iterations):
@@ -3865,6 +3950,9 @@ class PlatformAdapter(VerbosityMixin, ABC):
                 # Execute the power test
                 power_test_result = power_test.run()
 
+                # Cache the power test result for metric extraction
+                self._last_power_test_result = power_test_result
+
                 # Display results
                 if self.very_verbose:
                     with contextlib.suppress(Exception):
@@ -3903,6 +3991,7 @@ class PlatformAdapter(VerbosityMixin, ABC):
                         "stream_id": query_result.get("stream_id", current_stream_id),
                         "position": query_result.get("position", 0),
                         "iteration": i + 1,  # Add iteration tracking
+                        "run_type": "measurement",
                     }
                     if not query_result["success"]:
                         platform_result["error"] = query_result.get("error", "Unknown error")
@@ -3949,7 +4038,10 @@ class PlatformAdapter(VerbosityMixin, ABC):
 
             # Create connection factory that wraps the platform adapter connection
             def connection_factory():
-                conn_wrapper = PlatformAdapterConnection(connection, self)
+                # Create thread-safe cursor for concurrent stream execution
+                # See: https://duckdb.org/docs/stable/guides/python/multiple_threads
+                stream_cursor = connection.cursor()
+                conn_wrapper = PlatformAdapterConnection(stream_cursor, self)
                 # Configure benchmark context for query validation
                 conn_wrapper.benchmark_type = "tpcds"
                 conn_wrapper.scale_factor = scale_factor
@@ -4074,7 +4166,10 @@ class PlatformAdapter(VerbosityMixin, ABC):
             )
 
             def connection_factory():
-                conn_wrapper = PlatformAdapterConnection(connection, self)
+                # Create thread-safe cursor for concurrent stream execution
+                # See: https://duckdb.org/docs/stable/guides/python/multiple_threads
+                stream_cursor = connection.cursor()
+                conn_wrapper = PlatformAdapterConnection(stream_cursor, self)
                 # Configure benchmark context for query validation
                 conn_wrapper.benchmark_type = "tpch"
                 conn_wrapper.scale_factor = scale_factor
@@ -4086,7 +4181,6 @@ class PlatformAdapter(VerbosityMixin, ABC):
                 scale_factor=scale_factor,
                 num_streams=num_streams,
                 verbose=verbose,
-                dialect=self.get_target_dialect(),
             )
 
             seed = run_config.get("seed")
@@ -4167,7 +4261,10 @@ class PlatformAdapter(VerbosityMixin, ABC):
 
             # Create connection factory that wraps the platform adapter connection
             def connection_factory():
-                conn_wrapper = PlatformAdapterConnection(connection, self)
+                # Create thread-safe cursor for concurrent stream execution
+                # See: https://duckdb.org/docs/stable/guides/python/multiple_threads
+                stream_cursor = connection.cursor()
+                conn_wrapper = PlatformAdapterConnection(stream_cursor, self)
                 # Configure benchmark context for query validation
                 conn_wrapper.benchmark_type = "tpcds"
                 conn_wrapper.scale_factor = scale_factor
@@ -4256,8 +4353,12 @@ class PlatformAdapter(VerbosityMixin, ABC):
             console.print(f"[green]Running TPC-H Maintenance Test (Scale Factor: {scale_factor})[/green]")
 
             def connection_factory():
-                conn_wrapper = PlatformAdapterConnection(connection, self)
-                # Configure benchmark context for query validation
+                # Create thread-safe cursor for maintenance operations
+                # See: https://duckdb.org/docs/stable/guides/python/multiple_threads
+                stream_cursor = connection.cursor()
+                # Use maintenance_mode=True to execute all queries directly on the connection
+                # (RF1/RF2 operations need real data, not validation-wrapped results)
+                conn_wrapper = PlatformAdapterConnection(stream_cursor, self, maintenance_mode=True)
                 conn_wrapper.benchmark_type = "tpch"
                 conn_wrapper.scale_factor = scale_factor
                 return conn_wrapper
@@ -4267,7 +4368,6 @@ class PlatformAdapter(VerbosityMixin, ABC):
                 scale_factor=scale_factor,
                 output_dir=Path(output_dir) if isinstance(output_dir, str) else output_dir,
                 verbose=verbose,
-                dialect=self.get_target_dialect(),
             )
 
             result = maintenance_test.run_maintenance_test(
@@ -4337,19 +4437,30 @@ class PlatformAdapter(VerbosityMixin, ABC):
 
 
 class PlatformAdapterConnection:
-    """Adapter to wrap platform adapter connections for TPC test classes."""
+    """Adapter to wrap platform adapter connections for TPC test classes.
+
+    Supports two modes:
+    - Validation mode (default): Routes queries through platform adapter for TPC validation
+    - Maintenance mode: Routes all queries directly to underlying connection for real data
+
+    Maintenance operations (RF1/RF2) require real query results and parameterized queries,
+    so they use maintenance mode. Power/throughput tests use validation mode for result checking.
+    """
 
-    def __init__(self, connection: Any, platform_adapter: PlatformAdapter):
+    def __init__(self, connection: Any, platform_adapter: PlatformAdapter, maintenance_mode: bool = False):
         """Initialize the connection adapter.
 
         Args:
             connection: Original platform connection
             platform_adapter: Platform adapter instance for query execution
+            maintenance_mode: If True, all queries bypass validation and execute directly
+                            on the underlying connection (needed for RF1/RF2 operations)
         """
         self.connection = connection
         self.platform_adapter = platform_adapter
         self.connection_string = getattr(connection, "connection_string", "platform_adapter_connection")
         self.dialect = getattr(platform_adapter, "get_target_dialect", lambda: "standard")()
+        self._maintenance_mode = maintenance_mode
 
         # Benchmark context for query validation (set by TPC test runners)
         self.benchmark_type: str | None = None
@@ -4370,15 +4481,35 @@ class PlatformAdapterConnection:
         self._current_query_id = query_id
         self._current_stream_id = stream_id
 
-    def execute(self, query: str):
+    def execute(self, query: str, parameters: tuple | list | None = None):
         """Execute a query using the platform adapter with validation support.
 
+        In maintenance mode, all queries execute directly on the underlying connection
+        to get real results (needed for RF1/RF2 operations that use INSERT/DELETE/SELECT).
+
+        In validation mode (default), non-parameterized queries use the platform adapter
+        for TPC result validation support.
+
         Args:
             query: SQL query to execute
+            parameters: Optional parameters for parameterized queries
 
         Returns:
-            Mock cursor with results and validation metadata
+            Cursor with results - either raw DB cursor (maintenance) or PlatformAdapterCursor
         """
+        # Maintenance mode: all queries execute directly on underlying connection
+        # This is needed for RF1/RF2 operations that require real data
+        if self._maintenance_mode:
+            if parameters:
+                return self.connection.execute(query, parameters)
+            else:
+                return self.connection.execute(query)
+
+        # Validation mode: parameterized queries still go through directly
+        if parameters:
+            return self.connection.execute(query, parameters)
+
+        # Non-parameterized queries use the platform adapter for validation support
         # Debug: Write query to file to see what's being executed
         try:
             with open("/tmp/tpc_debug_queries.log", "a") as f:
@@ -4399,10 +4530,19 @@ class PlatformAdapterConnection:
         return PlatformAdapterCursor(result)
 
     def commit(self):
-        """Mock commit method."""
+        """Commit transaction on underlying connection."""
+        if hasattr(self.connection, "commit"):
+            self.connection.commit()
+
+    def rollback(self):
+        """Rollback transaction on underlying connection."""
+        if hasattr(self.connection, "rollback"):
+            self.connection.rollback()
 
     def close(self):
-        """Mock close method."""
+        """Close underlying connection."""
+        if hasattr(self.connection, "close"):
+            self.connection.close()
 
 
 class PlatformAdapterCursor:

benchbox/platforms/base/cloud_spark/config.py

@@ -61,6 +61,7 @@ class CloudPlatform(Enum):
     SYNAPSE = "synapse"
     GLUE = "glue"
     FABRIC = "fabric"
+    QUANTON = "quanton"
     LOCAL = "local"
 
 
@@ -478,6 +479,13 @@ class SparkConfigOptimizer:
             # Synapse-specific optimizations
             config.extra["spark.sql.optimizer.dynamicPartitionPruning.enabled"] = "true"
 
+        elif platform == CloudPlatform.QUANTON:
+            # Onehouse Quanton-specific optimizations
+            config.extra["spark.sql.optimizer.dynamicPartitionPruning.enabled"] = "true"
+            config.extra["spark.sql.parquet.filterPushdown"] = "true"
+            # Quanton uses intelligent lakehouse I/O optimization
+            config.extra["spark.sql.adaptive.advisoryPartitionSizeInBytes"] = "67108864"  # 64MB
+
     @classmethod
     def merge_configs(cls, *configs: SparkConfig) -> SparkConfig:
         """Merge multiple SparkConfigs, later configs override earlier.

benchbox/platforms/base/cloud_spark/mixins.py

@@ -214,6 +214,7 @@ class SparkTableFormat(str, Enum):
 
     DELTA = "delta"  # Delta Lake (Databricks, EMR, Dataproc with Delta)
     ICEBERG = "iceberg"  # Apache Iceberg
+    HUDI = "hudi"  # Apache Hudi (Onehouse, AWS EMR, Dataproc)
     PARQUET = "parquet"  # Apache Parquet (native Spark)
     HIVE = "hive"  # Legacy Hive format
 
@@ -290,6 +291,8 @@ class SparkDDLGeneratorMixin:
             return self._generate_delta_tuning(table_tuning, platform_opts)
         elif table_format == SparkTableFormat.ICEBERG:
             return self._generate_iceberg_tuning(table_tuning, platform_opts)
+        elif table_format == SparkTableFormat.HUDI:
+            return self._generate_hudi_tuning(table_tuning, platform_opts)
         elif table_format == SparkTableFormat.PARQUET:
             return self._generate_parquet_tuning(table_tuning, platform_opts)
         elif table_format == SparkTableFormat.HIVE:
@@ -480,6 +483,99 @@ class SparkDDLGeneratorMixin:
             # Default to identity transform
             return col_name
 
+    def _generate_hudi_tuning(
+        self,
+        table_tuning: TableTuning | None,
+        platform_opts: PlatformOptimizationConfiguration | None = None,
+    ) -> TuningClauses:
+        """Generate Apache Hudi tuning clauses.
+
+        Hudi supports:
+        - PARTITIONED BY (col1, col2) with hive_style_partitioning
+        - TBLPROPERTIES for:
+          - hoodie.table.name (table name for metadata)
+          - hoodie.datasource.write.recordkey.field (required: record key for dedup)
+          - hoodie.datasource.write.precombine.field (ordering field for updates)
+          - hoodie.table.type (COPY_ON_WRITE default, MERGE_ON_READ option)
+          - hoodie.datasource.write.operation (insert, upsert, bulk_insert)
+          - hoodie.datasource.write.hive_style_partitioning (for partition path)
+
+        Unlike Delta Lake/Iceberg, Hudi requires explicit record key and precombine
+        field configuration. These must be provided via platform_opts or detected
+        from table schema.
+        """
+        from benchbox.core.tuning.ddl_generator import TuningClauses
+        from benchbox.core.tuning.interface import TuningType
+
+        clauses = TuningClauses()
+
+        # Set table format
+        clauses.additional_clauses.append("USING HUDI")
+
+        # Get Hudi-specific configuration from platform_opts
+        record_key = None
+        precombine_field = None
+        table_type = "COPY_ON_WRITE"  # Default: better for analytics reads
+        write_operation = "upsert"  # Default write mode
+
+        if platform_opts:
+            record_key = getattr(platform_opts, "record_key", None)
+            precombine_field = getattr(platform_opts, "precombine_field", None)
+            table_type = getattr(platform_opts, "hudi_table_type", table_type)
+            write_operation = getattr(platform_opts, "hudi_write_operation", write_operation)
+
+        # Record key is required - use sensible defaults if not provided
+        if record_key:
+            clauses.table_properties["hoodie.datasource.write.recordkey.field"] = record_key
+        # Note: If no record_key is provided, the caller should set it based on schema
+
+        # Precombine field for ordering during updates
+        if precombine_field:
+            clauses.table_properties["hoodie.datasource.write.precombine.field"] = precombine_field
+
+        # Table type: COW for analytics (faster reads), MOR for streaming (faster writes)
+        clauses.table_properties["hoodie.table.type"] = table_type
+
+        # Write operation mode
+        clauses.table_properties["hoodie.datasource.write.operation"] = write_operation
+
+        if not table_tuning:
+            return clauses
+
+        # Handle partitioning
+        partition_columns = table_tuning.get_columns_by_type(TuningType.PARTITIONING)
+        if partition_columns:
+            sorted_cols = sorted(partition_columns, key=lambda c: c.order)
+            col_names = [c.name for c in sorted_cols]
+            clauses.partition_by = f"PARTITIONED BY ({', '.join(col_names)})"
+
+            # Enable hive-style partitioning for better compatibility
+            clauses.table_properties["hoodie.datasource.write.hive_style_partitioning"] = "true"
+
+        # Handle distribution via Hudi's file group assignment
+        # Hudi uses record key for distribution, not explicit CLUSTERED BY
+        distribution_columns = table_tuning.get_columns_by_type(TuningType.DISTRIBUTION)
+        if distribution_columns and not record_key:
+            # Use first distribution column as record key if not explicitly set
+            sorted_cols = sorted(distribution_columns, key=lambda c: c.order)
+            clauses.table_properties["hoodie.datasource.write.recordkey.field"] = sorted_cols[0].name
+
+        # Handle sorting via Hudi's clustering
+        sort_columns = table_tuning.get_columns_by_type(TuningType.SORTING)
+        cluster_columns = table_tuning.get_columns_by_type(TuningType.CLUSTERING)
+
+        all_sort_cols = list(sort_columns) + [c for c in cluster_columns if c not in sort_columns]
+        if all_sort_cols:
+            sorted_cols = sorted(all_sort_cols, key=lambda c: c.order)
+            col_names = [c.name for c in sorted_cols]
+
+            # Enable Hudi clustering for sorted data layout
+            clauses.table_properties["hoodie.clustering.inline"] = "true"
+            clauses.table_properties["hoodie.clustering.inline.max.commits"] = "4"
+            clauses.table_properties["hoodie.clustering.plan.strategy.sort.columns"] = ",".join(col_names)
+
+        return clauses
+
     def _generate_parquet_tuning(
         self,
         table_tuning: TableTuning | None,