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

benchbox/core/runner/dataframe_runner.py

@@ -18,9 +18,7 @@ from __future__ import annotations
 
 import logging
 import time
-import uuid
 from dataclasses import dataclass
-from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -35,11 +33,15 @@ from benchbox.core.dataframe import (
     validate_scale_factor,
 )
 from benchbox.core.dataframe.data_loader import DataFrameDataLoader, get_tpch_column_names
+from benchbox.core.results import (
+    BenchmarkInfoInput,
+    ResultBuilder,
+    build_platform_info,
+    normalize_query_result,
+)
+from benchbox.core.results.builder import RunConfigInput, normalize_benchmark_id
 from benchbox.core.results.models import (
     BenchmarkResults,
-    DataLoadingPhase,
-    ExecutionPhases,
-    SetupPhase,
     TableLoadingStats,
 )
 from benchbox.monitoring import PerformanceMonitor
@@ -67,6 +69,8 @@ class DataFrameRunOptions:
     force_regenerate: bool = False
     prefer_parquet: bool = True
     cache_dir: Path | None = None
+    verbose: bool = False
+    very_verbose: bool = False
 
 
 def run_dataframe_benchmark(
@@ -98,22 +102,64 @@ def run_dataframe_benchmark(
         BenchmarkResults with execution details
     """
     phases = phases or DataFramePhases()
-    options = options or DataFrameRunOptions()
-
-    start_time = time.time()
-    execution_id = uuid.uuid4().hex[:8]
+    if isinstance(options, dict):
+        options = DataFrameRunOptions(**options)
+    else:
+        options = options or DataFrameRunOptions()
+    verbosity = verbosity or VerbositySettings.default()
 
     platform_name = adapter.platform_name
     scale_factor = getattr(benchmark_config, "scale_factor", 1.0)
+    test_execution_type = getattr(benchmark_config, "test_execution_type", "standard")
+
+    # Check for unsupported maintenance phase
+    if test_execution_type in ("maintenance", "combined"):
+        raise NotImplementedError(
+            f"Maintenance phase is not yet implemented for DataFrame mode.\n\n"
+            f"DataFrame platforms like Spark (Delta Lake, Iceberg), Polars, and others "
+            f"can support maintenance operations (INSERT/UPDATE/DELETE), but this "
+            f"functionality has not been implemented yet.\n\n"
+            f"For now, please use SQL mode (e.g., --platform duckdb) for maintenance "
+            f"phase benchmarks.\n\n"
+            f"Requested: test_execution_type={test_execution_type}, platform={platform_name}"
+        )
 
     logger.info(f"Starting DataFrame benchmark: {benchmark_config.name}")
     logger.info(f"Platform: {platform_name}, Scale Factor: {scale_factor}")
 
+    # Build platform info using standardized extractor
+    platform_info = build_platform_info(adapter, execution_mode="dataframe")
+
+    # Create result builder
+    builder = ResultBuilder(
+        benchmark=BenchmarkInfoInput(
+            name=benchmark_config.name,
+            scale_factor=scale_factor,
+            test_type=test_execution_type if test_execution_type != "standard" else "power",
+            benchmark_id=normalize_benchmark_id(benchmark_config.name),
+            display_name=getattr(benchmark_config, "display_name", benchmark_config.name),
+        ),
+        platform=platform_info,
+    )
+    builder.mark_started()
+
+    options_map = getattr(benchmark_config, "options", {}) or {}
+    builder.set_run_config(
+        RunConfigInput(
+            compression_type=options_map.get("compression_type"),
+            compression_level=options_map.get("compression_level"),
+            seed=options_map.get("seed"),
+            phases=options_map.get("phases"),
+            query_subset=getattr(benchmark_config, "queries", None),
+            tuning_mode=options_map.get("tuning_mode"),
+            tuning_config=options_map.get("df_tuning_config"),
+        )
+    )
+
     # Initialize result tracking
     query_results: list[dict[str, Any]] = []
     table_stats: dict[str, int] = {}
     load_time = 0.0
-    setup_phase = None
 
     try:
         # Pre-execution memory check
@@ -146,15 +192,17 @@ def run_dataframe_benchmark(
             load_time = time.time() - load_start
             logger.info(f"Data loading completed in {load_time:.2f}s")
 
-            setup_phase = SetupPhase(
-                data_loading=DataLoadingPhase(
-                    duration_ms=int(load_time * 1000),
-                    status="SUCCESS",
-                    total_rows_loaded=sum(table_stats.values()),
-                    tables_loaded=len(table_stats),
-                    per_table_stats=per_table_stats,
+            # Add table stats to builder
+            for table_name, stats in per_table_stats.items():
+                builder.add_table_stats(
+                    table_name,
+                    stats.rows,
+                    load_time_ms=stats.load_time_ms,
+                    status=stats.status,
+                    error_message=stats.error_message,
                 )
-            )
+            builder.set_loading_time(load_time * 1000)
+            builder.set_phase_status("data_loading", "COMPLETED", load_time * 1000)
 
         # Execute phase
         if phases.execute:
@@ -166,62 +214,23 @@ def run_dataframe_benchmark(
                 monitor=monitor,
             )
 
-        # Compute summary metrics
-        total_time = time.time() - start_time
-        successful = sum(1 for r in query_results if r.get("status") == "SUCCESS")
-        failed = len(query_results) - successful
+            # Add query results to builder
+            for qr in query_results:
+                builder.add_query_result(normalize_query_result(qr))
+            builder.set_phase_status("power_test", "COMPLETED")
 
-        total_exec_time = sum(r.get("execution_time", 0) for r in query_results)
-        avg_time = total_exec_time / len(query_results) if query_results else 0.0
-
-        return BenchmarkResults(
-            benchmark_name=getattr(benchmark_config, "display_name", benchmark_config.name),
-            platform=f"{platform_name} (DataFrame)",
-            scale_factor=scale_factor,
-            execution_id=execution_id,
-            timestamp=datetime.now(),
-            duration_seconds=total_time,
-            total_queries=len(query_results),
-            successful_queries=successful,
-            failed_queries=failed,
-            query_results=query_results,
-            total_execution_time=total_exec_time,
-            average_query_time=avg_time,
-            data_loading_time=load_time,
-            total_rows_loaded=sum(table_stats.values()),
-            table_statistics=table_stats,
-            execution_phases=ExecutionPhases(setup=setup_phase) if setup_phase else None,
-            execution_metadata={
-                "execution_mode": "dataframe",
-                "dataframe_platform": platform_name,
-                "adapter_info": adapter.get_platform_info() if hasattr(adapter, "get_platform_info") else {},
-            },
-            validation_status="PASSED" if failed == 0 else "FAILED",
-            platform_info=adapter.get_platform_info() if hasattr(adapter, "get_platform_info") else {},
-            test_execution_type=getattr(benchmark_config, "test_execution_type", "standard"),
-        )
+        builder.mark_completed()
+        return builder.build()
 
     except Exception as e:
         logger.error(f"DataFrame benchmark failed: {e}")
-        return BenchmarkResults(
-            benchmark_name=getattr(benchmark_config, "display_name", benchmark_config.name),
-            platform=f"{platform_name} (DataFrame)",
-            scale_factor=scale_factor,
-            execution_id=execution_id,
-            timestamp=datetime.now(),
-            duration_seconds=time.time() - start_time,
-            total_queries=0,
-            successful_queries=0,
-            failed_queries=0,
-            query_results=[],
-            validation_status="FAILED",
-            validation_details={"error": str(e), "error_type": type(e).__name__},
-            execution_metadata={
-                "execution_mode": "dataframe",
-                "dataframe_platform": platform_name,
-                "error": str(e),
-            },
+        builder.set_validation_status(
+            "FAILED",
+            {"error": str(e), "error_type": type(e).__name__},
         )
+        builder.add_execution_metadata("error", str(e))
+        builder.mark_completed()
+        return builder.build()
 
 
 def _load_dataframe_data(
@@ -250,9 +259,12 @@ def _load_dataframe_data(
     # Get data paths
     if benchmark_instance and hasattr(benchmark_instance, "tables") and benchmark_instance.tables:
         # Use benchmark's pre-generated data
-        data_paths = {
-            name: Path(path) if not isinstance(path, Path) else path for name, path in benchmark_instance.tables.items()
-        }
+        data_paths: dict[str, list[Path]] = {}
+        for name, path in benchmark_instance.tables.items():
+            if isinstance(path, list):
+                data_paths[name] = [Path(p) if not isinstance(p, Path) else p for p in path]
+            else:
+                data_paths[name] = [Path(path) if not isinstance(path, Path) else path]
         logger.info(f"Using benchmark-provided data: {len(data_paths)} tables")
     elif data_dir and data_dir.exists():
         # Use provided data directory
@@ -262,18 +274,18 @@ def _load_dataframe_data(
         raise ValueError("No data source available. Either provide data_dir or generate data first.")
 
     # Get schema info for column names
-    benchmark_name = benchmark_config.name.lower()
-    column_names_map = get_tpch_column_names() if "tpch" in benchmark_name or "tpc-h" in benchmark_name else {}
+    benchmark_id = normalize_benchmark_id(benchmark_config.name)
+    column_names_map = get_tpch_column_names() if benchmark_id == "tpch" else {}
 
     # Load tables
     table_stats: dict[str, int] = {}
     per_table_stats: dict[str, TableLoadingStats] = {}
 
-    for table_name, file_path in data_paths.items():
+    for table_name, file_paths in data_paths.items():
         load_start = time.time()
         try:
             column_names = column_names_map.get(table_name.lower())
-            row_count = adapter.load_table(ctx, table_name.lower(), [file_path], column_names=column_names)
+            row_count = adapter.load_table(ctx, table_name.lower(), file_paths, column_names=column_names)
             load_time_ms = int((time.time() - load_start) * 1000)
 
             table_stats[table_name] = row_count
@@ -308,15 +320,15 @@ def _execute_dataframe_queries(
     """Execute DataFrame queries with warmup and measurement iterations.
 
     Follows TPC power test methodology:
-    1. Warmup iterations (default 1): Prime caches, not included in results
-    2. Measurement iterations (default 3): Timed runs, results aggregated
+    1. Warmup iterations (default 1): Prime caches, emitted as warmup results
+    2. Measurement iterations (default 3): Timed runs, results emitted per iteration
 
     Each iteration uses a different stream_id for query permutation, matching
     the SQL runner behavior. This ensures each iteration executes queries in
     a different order per TPC-H/TPC-DS specification.
 
     Returns:
-        List of query result dictionaries with timing from measurement iterations
+        List of query result dictionaries with warmup + measurement iterations
     """
     # Get warmup and iteration counts from config options
     options = getattr(benchmark_config, "options", {}) or {}
@@ -333,12 +345,21 @@ def _execute_dataframe_queries(
     query_subset = getattr(benchmark_config, "queries", None)
     query_filter: set[str] | None = None
     if query_subset:
-        query_filter = {str(q) for q in query_subset}
+        normalized: set[str] = set()
+        for q in query_subset:
+            q_str = str(q).strip().upper()
+            if q_str.startswith("Q"):
+                normalized.add(q_str)
+                normalized.add(q_str[1:])
+            else:
+                normalized.add(q_str)
+                normalized.add(f"Q{q_str}")
+        query_filter = normalized
 
     # Get initial query set to determine total count
     initial_queries = _get_queries_for_benchmark(benchmark_config, benchmark_instance, stream_id=0)
     if query_filter:
-        initial_queries = [q for q in initial_queries if q.query_id in query_filter]
+        initial_queries = [q for q in initial_queries if q.query_id.upper() in query_filter]
 
     if not initial_queries:
         logger.warning("No queries found for execution")
@@ -348,7 +369,9 @@ def _execute_dataframe_queries(
     logger.info(f"Executing {total_queries} queries")
     logger.info(f"Warmup iterations: {warmup_iterations}, Measurement iterations: {measurement_iterations}")
 
-    # Execute warmup iterations (not timed, not included in results)
+    query_results: list[dict[str, Any]] = []
+
+    # Execute warmup iterations (emit results)
     # Each warmup uses a different stream_id (0, 1, 2, ...)
     if warmup_iterations > 0:
         console.print(f"\n[yellow]Running {warmup_iterations} warmup iteration(s)...[/yellow]")
@@ -358,14 +381,25 @@ def _execute_dataframe_queries(
                 benchmark_config, benchmark_instance, stream_id=warmup_stream_id
             )
             if query_filter:
-                warmup_queries = [q for q in warmup_queries if q.query_id in query_filter]
+                warmup_queries = [q for q in warmup_queries if q.query_id.upper() in query_filter]
 
             console.print(f"[dim]Warmup {warmup_iter + 1}/{warmup_iterations} (stream {warmup_stream_id})[/dim]")
             for query in warmup_queries:
                 try:
-                    adapter.execute_query(ctx, query)
+                    result = adapter.execute_query(ctx, query)
+                    result = dict(result)
                 except Exception as e:
                     logger.warning(f"Warmup query {query.query_id} failed: {e}")
+                    result = {
+                        "query_id": query.query_id,
+                        "status": "FAILED",
+                        "error": str(e),
+                        "execution_time_seconds": 0.0,
+                    }
+                result["iteration"] = 0
+                result["stream_id"] = warmup_stream_id
+                result["run_type"] = "warmup"
+                query_results.append(result)
 
     # Execute measurement iterations
     # Each measurement iteration uses a different stream_id (continues from warmup)
@@ -373,11 +407,6 @@ def _execute_dataframe_queries(
         f"\n[cyan]Running {measurement_iterations} measurement iteration(s) with {total_queries} queries each...[/cyan]"
     )
 
-    # Collect results across all measurement iterations
-    all_iteration_results: dict[str, list[dict[str, Any]]] = {}
-    for q in initial_queries:
-        all_iteration_results[q.query_id] = []
-
     for iteration in range(measurement_iterations):
         # Each measurement iteration uses a unique stream_id
         # Stream IDs continue from where warmup left off
@@ -386,30 +415,33 @@ def _execute_dataframe_queries(
             benchmark_config, benchmark_instance, stream_id=measurement_stream_id
         )
         if query_filter:
-            measurement_queries = [q for q in measurement_queries if q.query_id in query_filter]
+            measurement_queries = [q for q in measurement_queries if q.query_id.upper() in query_filter]
 
         console.print(
             f"\n[green]Iteration {iteration + 1}/{measurement_iterations} (stream {measurement_stream_id})[/green]"
         )
 
         for i, query in enumerate(measurement_queries, 1):
-            console.print(f"[blue]Executing query {i}/{total_queries}: {query.query_id}[/blue]")
+            if options.get("verbose") or options.get("very_verbose"):
+                console.print(f"[blue]Executing query {i}/{total_queries}: {query.query_id}[/blue]")
 
             def execute_single_query(q=query):
                 """Execute a single query and return the result."""
                 try:
                     result = adapter.execute_query(ctx, q)
-                    all_iteration_results[q.query_id].append(result)
+                    result = dict(result)
                 except Exception as e:
                     logger.error(f"Query {q.query_id} failed: {e}")
-                    all_iteration_results[q.query_id].append(
-                        {
-                            "query_id": q.query_id,
-                            "status": "FAILED",
-                            "error": str(e),
-                            "execution_time_seconds": 0.0,
-                        }
-                    )
+                    result = {
+                        "query_id": q.query_id,
+                        "status": "FAILED",
+                        "error": str(e),
+                        "execution_time_seconds": 0.0,
+                    }
+                result["iteration"] = iteration + 1
+                result["stream_id"] = measurement_stream_id
+                result["run_type"] = "measurement"
+                query_results.append(result)
 
             # Use time_operation context manager for consistent monitoring
             if monitor:
@@ -418,34 +450,6 @@ def _execute_dataframe_queries(
             else:
                 execute_single_query()
 
-    # Aggregate results: use minimum time across iterations (TPC methodology)
-    query_results: list[dict[str, Any]] = []
-    for query in initial_queries:
-        iteration_results = all_iteration_results[query.query_id]
-        if not iteration_results:
-            continue
-
-        # Find the best (fastest successful) run
-        successful_runs = [r for r in iteration_results if r.get("status") == "SUCCESS"]
-
-        if successful_runs:
-            # Use minimum execution time (TPC standard)
-            best_run = min(successful_runs, key=lambda r: r.get("execution_time_seconds", float("inf")))
-            best_run = dict(best_run)  # Copy to avoid modifying original
-
-            # Add iteration metadata
-            times = [r.get("execution_time_seconds", 0) for r in successful_runs]
-            best_run["iterations"] = measurement_iterations
-            best_run["iteration_times"] = times
-            best_run["min_time"] = min(times) if times else 0
-            best_run["max_time"] = max(times) if times else 0
-            best_run["avg_time"] = sum(times) / len(times) if times else 0
-
-            query_results.append(best_run)
-        else:
-            # All iterations failed - report the last failure
-            query_results.append(iteration_results[-1])
-
     return query_results
 
 
@@ -469,14 +473,14 @@ def _get_queries_for_benchmark(
     Returns:
         List of DataFrameQuery objects in execution order for the given stream.
     """
-    benchmark_name = benchmark_config.name.lower()
+    benchmark_id = normalize_benchmark_id(benchmark_config.name)
 
     # Use provided stream_id, or fall back to config, or default to 0
     if stream_id is None:
         stream_id = getattr(benchmark_config, "stream_id", 0)
 
     # Check registry for pre-defined queries
-    if "tpch" in benchmark_name or "tpc-h" in benchmark_name:
+    if benchmark_id == "tpch":
         from benchbox.core.tpch.dataframe_queries import TPCH_DATAFRAME_QUERIES
         from benchbox.core.tpch.streams import TPCHStreams
 
@@ -494,7 +498,7 @@ def _get_queries_for_benchmark(
                 logger.warning(f"Query {query_id} not found in TPC-H DataFrame registry")
         return queries
 
-    elif "tpcds" in benchmark_name or "tpc-ds" in benchmark_name:
+    elif benchmark_id == "tpcds":
         from benchbox.core.tpcds.dataframe_queries import TPCDS_DATAFRAME_QUERIES
         from benchbox.core.tpcds.streams import PermutationMode, TPCDSPermutationGenerator
 

benchbox/core/runner/runner.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import contextlib
 import json
 import logging
+import uuid
 from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Any
@@ -32,9 +33,11 @@ from benchbox.core.results.models import (
     BenchmarkResults,
 )
 from benchbox.core.runner.conversion import FormatConversionOrchestrator
+from benchbox.core.schemas import ExecutionContext
 from benchbox.core.validation import ValidationResult
 from benchbox.monitoring import PerformanceMonitor, ResourceMonitor, attach_snapshot_to_result
 from benchbox.platforms import get_platform_adapter
+from benchbox.platforms.dataframe.benchmark_mixin import DataFramePhases, DataFrameRunOptions
 from benchbox.utils.cloud_storage import create_path_handler
 from benchbox.utils.format_converters import ConversionOptions
 from benchbox.utils.verbosity import VerbosityMixin, VerbositySettings
@@ -375,7 +378,7 @@ def _run_format_conversion(
         return None
 
     # Validate format
-    allowed_formats = {"parquet", "delta", "iceberg"}
+    allowed_formats = {"parquet", "vortex", "delta", "iceberg"}
     if convert_format.lower() not in allowed_formats:
         logger.error(f"Invalid format: {convert_format}. Allowed: {allowed_formats}")
         return None
@@ -455,6 +458,7 @@ def run_benchmark_lifecycle(
     verbosity: VerbositySettings | None = None,
     monitor: PerformanceMonitor | None = None,
     enable_resource_monitoring: bool = True,
+    execution_context: ExecutionContext | None = None,
 ) -> BenchmarkResults:
     """Run the complete benchmark lifecycle in core, returning BenchmarkResults.
 
@@ -544,14 +548,24 @@ def run_benchmark_lifecycle(
             _run_format_conversion(benchmark, benchmark_config)
 
     if test_type == "data_only":
+        execution_id = uuid.uuid4().hex[:8]
         result_obj = benchmark.create_enhanced_benchmark_result(
             platform="data_only",
             query_results=[],
             duration_seconds=0.0,
             phases={"data_generation": {"status": "COMPLETED"}},
-            execution_metadata={"mode": "data_only"},
+            execution_metadata={
+                "mode": "datagen",
+                "benchmark_id": benchmark_config.name,
+                "phase_status": {"data_generation": {"status": "COMPLETED"}},
+            },
+            execution_id=execution_id,
         )
-        return _finalize_validation_metadata(result_obj, validation_records)
+        result_obj._benchmark_id_override = benchmark_config.name
+        result_obj = _finalize_validation_metadata(result_obj, validation_records)
+        if execution_context is not None:
+            result_obj.execution_context = execution_context.model_dump()
+        return result_obj
 
     adapter = platform_adapter
     if adapter is None and database_config is not None:
@@ -570,6 +584,11 @@ def run_benchmark_lifecycle(
     if adapter is not None and isinstance(adapter, VerbosityMixin):
         adapter.apply_verbosity(verbosity_settings)
 
+    options = getattr(benchmark_config, "options", {}) or {}
+
+    # Detect DataFrame adapter by checking for 'family' attribute
+    is_dataframe_adapter = hasattr(adapter, "family") and adapter.family in ("expression", "pandas")
+
     # Check if we should run load-only mode:
     # - Explicit test_type == "load_only" OR
     # - Phases indicate load without execute (e.g., --phases generate,load)
@@ -579,18 +598,49 @@ def run_benchmark_lifecycle(
         if adapter is None:
             raise RuntimeError("Load-only mode requires a platform adapter and database configuration")
 
-        result_obj, postload_result = _execute_load_only_mode(
-            benchmark=benchmark,
-            benchmark_config=benchmark_config,
-            adapter=adapter,
-            platform_config=platform_config,
-            validation_opts=validation_opts,
-        )
+        if is_dataframe_adapter:
+            from pathlib import Path
+
+            data_dir = getattr(benchmark, "output_dir", None)
+            if data_dir is None and output_root:
+                data_dir = Path(output_root)
+            elif isinstance(data_dir, str):
+                data_dir = Path(data_dir)
+
+            df_phases = DataFramePhases(load=True, execute=False)
+            df_options = DataFrameRunOptions(
+                ignore_memory_warnings=bool(options.get("ignore_memory_warnings", False)),
+                force_regenerate=bool(options.get("force_regenerate", False)),
+                prefer_parquet=bool(options.get("prefer_parquet", True)),
+                verbose=verbosity_settings.verbose,
+                very_verbose=verbosity_settings.very_verbose,
+            )
 
-        if postload_result is not None:
-            validation_records.append(("post_load", postload_result))
+            result_obj = adapter.run_benchmark(
+                benchmark,
+                benchmark_config=benchmark_config,
+                system_profile=system_profile,
+                data_dir=data_dir,
+                phases=df_phases,
+                options=df_options,
+                monitor=monitor,
+            )
+        else:
+            result_obj, postload_result = _execute_load_only_mode(
+                benchmark=benchmark,
+                benchmark_config=benchmark_config,
+                adapter=adapter,
+                platform_config=platform_config,
+                validation_opts=validation_opts,
+            )
 
-        return _finalize_validation_metadata(result_obj, validation_records)
+            if postload_result is not None:
+                validation_records.append(("post_load", postload_result))
+
+        result_obj = _finalize_validation_metadata(result_obj, validation_records)
+        if execution_context is not None:
+            result_obj.execution_context = execution_context.model_dump()
+        return result_obj
 
     # Only return early for setup-only scenarios (no loading, no execution)
     # This prevents skipping schema creation when phases.load=True
@@ -610,9 +660,11 @@ def run_benchmark_lifecycle(
             phases={"setup": {"status": "COMPLETED"}},
             execution_metadata={"mode": "setup_only"},
         )
-        return _finalize_validation_metadata(result_obj, validation_records)
+        result_obj = _finalize_validation_metadata(result_obj, validation_records)
+        if execution_context is not None:
+            result_obj.execution_context = execution_context.model_dump()
+        return result_obj
 
-    options = getattr(benchmark_config, "options", {}) or {}
     iterations = int(
         options.get("power_iterations", GENERIC_POWER_DEFAULT_MEASUREMENT_ITERATIONS)
         or GENERIC_POWER_DEFAULT_MEASUREMENT_ITERATIONS
@@ -643,10 +695,47 @@ def run_benchmark_lifecycle(
         power_fail_fast=fail_fast,
     )
 
-    kwargs = {k: v for k, v in run_config.__dict__.items() if k != "benchmark"}
-    result_obj = adapter.run_benchmark(benchmark, **kwargs)
+    if is_dataframe_adapter:
+        # DataFrame adapter execution path
+        from pathlib import Path
+
+        # Get data directory from benchmark or output_root
+        data_dir = getattr(benchmark, "output_dir", None)
+        if data_dir is None and output_root:
+            data_dir = Path(output_root)
+        elif isinstance(data_dir, str):
+            data_dir = Path(data_dir)
+
+        # Create DataFrame-specific phases and options
+        df_phases = DataFramePhases(
+            load=True,  # DataFrame always loads from files
+            execute=phases.execute,
+        )
+        df_options = DataFrameRunOptions(
+            ignore_memory_warnings=bool(options.get("ignore_memory_warnings", False)),
+            force_regenerate=bool(options.get("force_regenerate", False)),
+            prefer_parquet=bool(options.get("prefer_parquet", True)),
+            verbose=verbosity_settings.verbose,
+            very_verbose=verbosity_settings.very_verbose,
+        )
 
-    if validation_opts.enable_postload_validation:
+        # Call DataFrame adapter's run_benchmark
+        result_obj = adapter.run_benchmark(
+            benchmark,
+            benchmark_config=benchmark_config,
+            system_profile=system_profile,
+            data_dir=data_dir,
+            phases=df_phases,
+            options=df_options,
+            monitor=monitor,
+        )
+    else:
+        # SQL adapter execution path (existing behavior)
+        kwargs = {k: v for k, v in run_config.__dict__.items() if k != "benchmark"}
+        result_obj = adapter.run_benchmark(benchmark, **kwargs)
+
+    # Postload validation only applies to SQL adapters (database validation)
+    if validation_opts.enable_postload_validation and not is_dataframe_adapter:
         postload_result = _run_postload_validation(adapter, benchmark_config, platform_config)
         if postload_result is not None:
             validation_records.append(("post_load", postload_result))
@@ -662,6 +751,10 @@ def run_benchmark_lifecycle(
         snapshot = monitor.snapshot()
         attach_snapshot_to_result(result_with_validation, snapshot)
 
+    # Attach execution context for reproducibility
+    if execution_context is not None:
+        result_with_validation.execution_context = execution_context.model_dump()
+
     return result_with_validation