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

benchbox/core/dryrun.py

@@ -21,6 +21,7 @@ from benchbox.core.config import (
     DryRunResult,
     SystemProfile,
 )
+from benchbox.core.results.builder import normalize_benchmark_id
 from benchbox.platforms import get_platform_adapter
 
 
@@ -52,15 +53,23 @@ class DryRunExecutor:
         """Execute a detailed dry run of the benchmark."""
         # Resolve execution mode from database config or platform default
         from benchbox.core.platform_registry import PlatformRegistry
+        from benchbox.core.runner.dataframe_runner import get_execution_mode
 
         execution_mode = "sql"  # default
         if database_config:
+            # First check explicit execution_mode on config
             execution_mode = getattr(database_config, "execution_mode", None)
             if execution_mode is None:
-                try:
-                    execution_mode = PlatformRegistry.get_default_mode(database_config.type)
-                except Exception:
-                    execution_mode = "sql"
+                # Use naming convention check (platform-df = dataframe mode)
+                execution_mode = get_execution_mode(database_config)
+                # Fall back to registry if not determined by naming convention
+                if execution_mode == "sql":
+                    try:
+                        registry_mode = PlatformRegistry.get_default_mode(database_config.type)
+                        if registry_mode == "dataframe":
+                            execution_mode = "dataframe"
+                    except Exception:
+                        pass  # Keep sql default
 
         result = DryRunResult(
             benchmark_config=self._serialize_config(benchmark_config),
@@ -80,7 +89,7 @@ class DryRunExecutor:
                 platform_adapter = None
                 result.platform_config = {"data_only": True}
             else:
-                platform_config = self._get_platform_config(database_config, system_profile)
+                platform_config = self._get_platform_config(database_config, system_profile, benchmark_config)
                 result.platform_config = platform_config
 
                 try:
@@ -284,13 +293,20 @@ class DryRunExecutor:
         return benchmark_class(**benchmark_config)
 
     def _get_platform_config(
-        self, database_config: Optional[DatabaseConfig], system_profile: SystemProfile
+        self,
+        database_config: Optional[DatabaseConfig],
+        system_profile: SystemProfile,
+        benchmark_config: Optional[BenchmarkConfig] = None,
     ) -> dict[str, Any]:
         from benchbox.core.platform_config import get_platform_config
 
         if database_config is None:
             return {"data_only": True}
-        return get_platform_config(database_config, system_profile)
+
+        benchmark_name = getattr(benchmark_config, "name", None) if benchmark_config else None
+        scale_factor = getattr(benchmark_config, "scale_factor", None) if benchmark_config else None
+
+        return get_platform_config(database_config, system_profile, benchmark_name, scale_factor)
 
     def _extract_queries(
         self,
@@ -306,21 +322,61 @@ class DryRunExecutor:
             if test_execution_type == "load_only":
                 return {}
 
-            # Check execution mode first - DataFrame mode uses different extraction
+            # Check for unsupported maintenance+dataframe combination BEFORE mode dispatch
+            if execution_mode == "dataframe" and test_execution_type in ("maintenance", "combined"):
+                return {
+                    "_maintenance_not_supported": (
+                        "-- Maintenance phase is not yet implemented for DataFrame mode.\n"
+                        "--\n"
+                        "-- DataFrame platforms like Spark (Delta Lake, Iceberg), Polars, and others\n"
+                        "-- can support maintenance operations (INSERT/UPDATE/DELETE), but this\n"
+                        "-- functionality has not been implemented yet.\n"
+                        "--\n"
+                        "-- For now, please use SQL mode (e.g., --platform duckdb) for maintenance\n"
+                        "-- phase benchmarks.\n"
+                        "--\n"
+                        f"-- Requested: test_execution_type={test_execution_type}, execution_mode={execution_mode}\n"
+                    )
+                }
+
+            # Check execution mode - DataFrame mode uses different extraction
             if execution_mode == "dataframe":
                 return self._extract_dataframe_queries(benchmark_config, benchmark, platform_type)
 
-            benchmark_name = getattr(benchmark, "_name", getattr(benchmark, "name", type(benchmark).__name__)).lower()
-
-            if (
-                ("tpcds" in benchmark_name or "tpc-ds" in benchmark_name)
-                and test_execution_type != "standard"
-                or ("tpch" in benchmark_name or "tpc-h" in benchmark_name)
-                and test_execution_type == "power"
-            ):
-                return self._extract_queries_via_real_test_execution(
-                    benchmark, benchmark_config, test_execution_type, platform_adapter
-                )
+            benchmark_name = getattr(benchmark, "_name", getattr(benchmark, "name", type(benchmark).__name__))
+            benchmark_id = normalize_benchmark_id(benchmark_name)
+
+            # Handle TPC-H with maintenance or combined phases
+            if benchmark_id == "tpch":
+                if test_execution_type == "maintenance":
+                    # Maintenance-only: just maintenance operations (no standard queries)
+                    return self._extract_tpch_maintenance_operations(benchmark, benchmark_config)
+                elif test_execution_type == "combined":
+                    # Combined: standard queries (Q1-Q22) + maintenance operations
+                    queries = self._extract_standard_queries(benchmark)
+                    maintenance_ops = self._extract_tpch_maintenance_operations(benchmark, benchmark_config)
+                    queries.update(maintenance_ops)
+                    return queries
+                elif test_execution_type == "power":
+                    return self._extract_queries_via_real_test_execution(
+                        benchmark, benchmark_config, test_execution_type, platform_adapter
+                    )
+
+            # Handle TPC-DS with maintenance or combined phases
+            if benchmark_id == "tpcds":
+                if test_execution_type == "maintenance":
+                    # Maintenance-only: just maintenance operations (no standard queries)
+                    return self._extract_tpcds_maintenance_operations(benchmark, benchmark_config)
+                elif test_execution_type == "combined":
+                    # Combined: standard queries (Q1-Q99) + maintenance operations
+                    queries = self._extract_standard_queries(benchmark)
+                    maintenance_ops = self._extract_tpcds_maintenance_operations(benchmark, benchmark_config)
+                    queries.update(maintenance_ops)
+                    return queries
+                elif test_execution_type != "standard":
+                    return self._extract_queries_via_real_test_execution(
+                        benchmark, benchmark_config, test_execution_type, platform_adapter
+                    )
 
             return self._extract_standard_queries(benchmark)
 
@@ -342,12 +398,18 @@ class DryRunExecutor:
 
             platform_adapter.enable_dry_run()
 
+            # Set benchmark_instance and scale_factor on adapter before create_connection()
+            # These are required for database validation during handle_existing_database()
+            platform_adapter.benchmark_instance = benchmark
+            platform_adapter.scale_factor = getattr(benchmark_config, "scale_factor", 1.0)
+
             connection = platform_adapter.create_connection()
 
-            benchmark_name = getattr(benchmark, "_name", getattr(benchmark, "name", type(benchmark).__name__)).lower()
+            benchmark_name = getattr(benchmark, "_name", getattr(benchmark, "name", type(benchmark).__name__))
+            benchmark_id = normalize_benchmark_id(benchmark_name)
             scale_factor = getattr(benchmark_config, "scale_factor", 1.0)
 
-            if "tpcds" in benchmark_name or "tpc-ds" in benchmark_name:
+            if benchmark_id == "tpcds":
                 return self._execute_tpcds_test_class(
                     benchmark,
                     benchmark_config,
@@ -356,7 +418,7 @@ class DryRunExecutor:
                     connection,
                     platform_adapter,
                 )
-            elif "tpch" in benchmark_name or "tpc-h" in benchmark_name:
+            elif benchmark_id == "tpch":
                 return self._execute_tpch_test_class(
                     benchmark,
                     benchmark_config,
@@ -431,6 +493,74 @@ class DryRunExecutor:
 
         return {}
 
+    def _extract_tpch_maintenance_operations(self, benchmark, benchmark_config: BenchmarkConfig) -> dict[str, str]:
+        """Extract TPC-H maintenance operation SQL for dry-run preview.
+
+        Uses TPCHMaintenanceTest.get_maintenance_operations_sql() to generate
+        actual SQL using the same code paths as real execution.
+        """
+        try:
+            from benchbox.core.tpch.maintenance_test import TPCHMaintenanceTest
+
+            scale_factor = getattr(benchmark_config, "scale_factor", 1.0)
+
+            # Create maintenance test instance (doesn't need real connection for SQL generation)
+            maintenance_test = TPCHMaintenanceTest(
+                connection_factory=lambda: None,  # Not used for SQL generation
+                scale_factor=scale_factor,
+                verbose=False,
+            )
+
+            # Get SQL statements using same generation logic as actual execution
+            operations = maintenance_test.get_maintenance_operations_sql(pair_id=0, placeholder="?")
+
+            # Flatten to dict format expected by dry-run output
+            # RF1 and RF2 each have multiple statements; join them
+            result = {}
+            for op_id, statements in operations.items():
+                result[op_id] = "\n\n".join(statements)
+
+            return result
+
+        except Exception as e:
+            return {"_maintenance_error": f"-- Failed to extract maintenance operations: {e}"}
+
+    def _extract_tpcds_maintenance_operations(self, benchmark, benchmark_config: BenchmarkConfig) -> dict[str, str]:
+        """Extract TPC-DS maintenance operation SQL for dry-run preview.
+
+        Uses TPCDSMaintenanceTest.get_maintenance_operations_sql() to generate
+        actual SQL using the same code paths as real execution.
+        """
+        try:
+            from benchbox.core.tpcds.maintenance_test import TPCDSMaintenanceTest
+
+            scale_factor = getattr(benchmark_config, "scale_factor", 1.0)
+
+            # Create maintenance test instance (doesn't need real connection for SQL generation)
+            maintenance_test = TPCDSMaintenanceTest(
+                benchmark=benchmark,
+                connection_factory=lambda: None,  # Not used for SQL generation
+                scale_factor=scale_factor,
+                verbose=False,
+            )
+
+            # Get SQL statements using same generation logic as actual execution
+            operations = maintenance_test.get_maintenance_operations_sql(placeholder="?")
+
+            # Flatten to dict format expected by dry-run output
+            # Each operation category may have multiple statements; join them
+            result = {}
+            for op_id, statements in operations.items():
+                if isinstance(statements, list):
+                    result[op_id] = "\n\n".join(statements)
+                else:
+                    result[op_id] = statements
+
+            return result
+
+        except Exception as e:
+            return {"_maintenance_error": f"-- Failed to extract TPC-DS maintenance operations: {e}"}
+
     def _extract_dataframe_queries(
         self,
         benchmark_config: BenchmarkConfig,

benchbox/core/expected_results/registry.py

@@ -194,17 +194,26 @@ class ExpectedResultsRegistry:
                 return None
 
         # Load results using provider (outside lock - this may be slow)
-        # Use flag to distinguish exception from intentional None return
-        had_exception = False
+        # Use flag to distinguish recoverable vs permanent failures
+        cache_failure = False
         try:
             results = provider(scale_factor)
+        except FileNotFoundError as e:
+            # Permanent failure: answers directory not found (won't change during session)
+            # Cache this failure to avoid noisy repeated warnings
+            logger.info(
+                f"Expected results not available for benchmark '{benchmark_key}' "
+                f"at scale factor {scale_factor}: {e}. Validation will be skipped."
+            )
+            results = None
+            cache_failure = True  # Cache to prevent repeated warnings
         except Exception as e:
+            # Transient failure: might succeed on retry (don't cache)
             logger.warning(
                 f"Failed to load expected results for benchmark '{benchmark_key}' "
                 f"at scale factor {scale_factor}: {e}. Will not cache this failure; retry allowed."
             )
             results = None
-            had_exception = True
         finally:
             # Always signal completion and cleanup loading state
             with self._lock:
@@ -216,8 +225,16 @@ class ExpectedResultsRegistry:
                         del self._loading[benchmark_key]
                     event.set()  # Signal other threads
 
-        # If load failed (exception), return None without caching (allows retry)
-        if had_exception:
+        # If permanent failure (FileNotFoundError), cache None to avoid repeated warnings
+        if cache_failure:
+            with self._lock:
+                if benchmark_key not in self._cache:
+                    self._cache[benchmark_key] = {}
+                self._cache[benchmark_key][scale_factor] = None
+            return None
+
+        # If transient failure, return None without caching (allows retry)
+        if results is None:
             return None
 
         # Cache the results under lock

benchbox/core/manifest/io.py

@@ -12,6 +12,7 @@ from benchbox.core.manifest.models import (
     PlanMetadata,
     TableFormats,
 )
+from benchbox.utils.file_format import is_csv_format, is_parquet_format, is_tpc_format
 
 
 def detect_version(manifest_dict: dict[str, Any]) -> int:
@@ -184,11 +185,11 @@ def _detect_format_from_files(files: list[FileEntry]) -> str:
         return "tbl"
 
     path = files[0].path
-    if ".parquet" in path:
+    if is_parquet_format(path):
         return "parquet"
-    elif ".tbl" in path or ".dat" in path:
+    elif is_tpc_format(path):
         return "tbl"
-    elif ".csv" in path:
+    elif is_csv_format(path):
         return "csv"
     else:
         return "tbl"

benchbox/core/metadata_primitives/__init__.py

@@ -42,6 +42,22 @@ from .complexity import (
     TypeComplexity,
     get_complexity_preset,
 )
+from .dataframe_operations import (
+    DATAFUSION_METADATA_CAPABILITIES,
+    OPERATION_CATEGORIES,
+    PANDAS_METADATA_CAPABILITIES,
+    POLARS_METADATA_CAPABILITIES,
+    PYSPARK_METADATA_CAPABILITIES,
+    DataFrameMetadataCapabilities,
+    DataFrameMetadataOperationsManager,
+    DataFrameMetadataResult,
+    MetadataOperationCategory,
+    MetadataOperationType,
+    UnsupportedOperationError,
+    get_dataframe_metadata_manager,
+    get_platform_capabilities,
+    get_unsupported_message,
+)
 from .generator import MetadataGenerator
 from .queries import MetadataPrimitivesQueryManager
 
@@ -65,4 +81,19 @@ __all__ = [
     "RoleHierarchyDepth",
     "TypeComplexity",
     "get_complexity_preset",
+    # DataFrame operations
+    "DATAFUSION_METADATA_CAPABILITIES",
+    "DataFrameMetadataCapabilities",
+    "DataFrameMetadataOperationsManager",
+    "DataFrameMetadataResult",
+    "MetadataOperationCategory",
+    "MetadataOperationType",
+    "OPERATION_CATEGORIES",
+    "PANDAS_METADATA_CAPABILITIES",
+    "POLARS_METADATA_CAPABILITIES",
+    "PYSPARK_METADATA_CAPABILITIES",
+    "UnsupportedOperationError",
+    "get_dataframe_metadata_manager",
+    "get_platform_capabilities",
+    "get_unsupported_message",
 ]