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

benchbox/core/tpch/maintenance_test.py

@@ -220,6 +220,93 @@ class TPCHMaintenanceTest:
 
             return result
 
+    def get_maintenance_operations_sql(
+        self,
+        pair_id: int = 0,
+        placeholder: str = "?",
+    ) -> dict[str, list[str]]:
+        """Generate maintenance operation SQL for dry-run preview.
+
+        Uses the same data generation and SQL construction logic as actual execution,
+        but skips FK validation and database queries.
+
+        Args:
+            pair_id: Maintenance pair identifier (affects generated keys)
+            placeholder: SQL parameter placeholder style ('?' for DuckDB/SQLite, '%s' for PostgreSQL)
+
+        Returns:
+            Dict mapping operation IDs ('RF1', 'RF2') to lists of SQL statements
+        """
+        import random
+
+        rf1_statements = []
+        rf2_statements = []
+
+        # RF1: Generate INSERT statements using same logic as _execute_rf1
+        num_orders = max(1, int(self.scale_factor * 1500 * 0.001))
+        orders = self._generate_rf1_orders_data(pair_id, num_orders)
+
+        # Generate lineitems for all orders
+        all_lineitems = []
+        for order in orders:
+            num_items = random.randint(1, 7)
+            lineitems = self._generate_rf1_lineitems_data(order["O_ORDERKEY"], num_items)
+            all_lineitems.extend(lineitems)
+
+        # Build INSERT SQL for orders (same logic as _execute_rf1 lines 538-557)
+        if orders:
+            columns = ", ".join(orders[0].keys())
+            batch_size = 100
+            for batch_start in range(0, len(orders), batch_size):
+                batch_orders = orders[batch_start : batch_start + batch_size]
+                values_placeholders = []
+                for order in batch_orders:
+                    row_placeholders = ", ".join([placeholder for _ in order])
+                    values_placeholders.append(f"({row_placeholders})")
+                insert_sql = f"INSERT INTO ORDERS ({columns}) VALUES {', '.join(values_placeholders)}"
+                # Add comment showing sample values for first few rows
+                sample_values = list(batch_orders[0].values())[:3] if batch_orders else []
+                rf1_statements.append(f"-- Sample values: {sample_values}...\n{insert_sql}")
+
+        # Build INSERT SQL for lineitems (same logic as _execute_rf1 lines 559-578)
+        if all_lineitems:
+            columns = ", ".join(all_lineitems[0].keys())
+            batch_size = 100
+            for batch_start in range(0, len(all_lineitems), batch_size):
+                batch_lineitems = all_lineitems[batch_start : batch_start + batch_size]
+                values_placeholders = []
+                for lineitem in batch_lineitems:
+                    row_placeholders = ", ".join([placeholder for _ in lineitem])
+                    values_placeholders.append(f"({row_placeholders})")
+                insert_sql = f"INSERT INTO LINEITEM ({columns}) VALUES {', '.join(values_placeholders)}"
+                sample_values = list(batch_lineitems[0].values())[:3] if batch_lineitems else []
+                rf1_statements.append(f"-- Sample values: {sample_values}...\n{insert_sql}")
+
+        # RF2: Generate DELETE statements
+        # In actual execution, order keys are retrieved from database.
+        # For dry-run, use sample order key range based on scale factor.
+        num_to_delete = max(1, int(self.scale_factor * 1500 * 0.001))
+        # Generate plausible order keys (1 to max based on SF)
+        max_order_key = int(6000000 * self.scale_factor)
+        sample_order_keys = list(range(1, min(num_to_delete + 1, max_order_key + 1)))
+
+        # SELECT statement to identify orders (same as _identify_old_orders)
+        rf2_statements.append(
+            f"-- Identify {num_to_delete} oldest orders to delete\n"
+            f"SELECT O_ORDERKEY FROM ORDERS ORDER BY O_ORDERDATE ASC LIMIT {num_to_delete}"
+        )
+
+        # DELETE lineitems first (same logic as _execute_rf2 lines 661-667)
+        placeholders_str = ", ".join([placeholder for _ in sample_order_keys])
+        rf2_statements.append(
+            f"-- Delete lineitems for identified orders\nDELETE FROM LINEITEM WHERE L_ORDERKEY IN ({placeholders_str})"
+        )
+
+        # DELETE orders (same logic as _execute_rf2 lines 669-673)
+        rf2_statements.append(f"-- Delete the orders\nDELETE FROM ORDERS WHERE O_ORDERKEY IN ({placeholders_str})")
+
+        return {"RF1": rf1_statements, "RF2": rf2_statements}
+
     def _generate_rf1_orders_data(self, pair_id: int, num_orders: int) -> list[dict[str, Any]]:
         """Generate new orders data for RF1.
 

benchbox/core/tpch/power_test.py

@@ -166,6 +166,14 @@ class TPCHPowerTest:
                 if validation_mode is None:
                     actual_validation_mode = "disabled" if not validation else "loose"
 
+        # Answer sets are only defined for stream 0; disable validation unless explicitly requested
+        if stream_id != 0 and validation and validation_mode is None:
+            validation = False
+            actual_validation_mode = "disabled"
+            self.logger.warning(
+                "⚠️  TPC-H answer sets are only available for stream 0. Disabling validation for stream_id != 0."
+            )
+
         # If validation is disabled, override mode
         if not validation:
             actual_validation_mode = "disabled"
@@ -335,12 +343,20 @@ class TPCHPowerTest:
                 result.query_results.append(query_result)
                 result.queries_executed += 1
 
-            # Calculate Power@Size metric
+            # Calculate Power@Size metric (geometric mean per TPC spec)
             total_execution_time = time.time() - start_time
-
-            # Power@Size = 3600 * SF / Power_Test_Time (in seconds)
-            if total_execution_time > 0:
-                result.power_at_size = (3600.0 * self.config.scale_factor) / total_execution_time
+            exec_times = [
+                qr["execution_time"]
+                for qr in result.query_results
+                if qr.get("success", True) and qr.get("execution_time", 0) > 0
+            ]
+            if exec_times:
+                from benchbox.core.results.metrics import TPCMetricsCalculator
+
+                result.power_at_size = TPCMetricsCalculator.calculate_power_at_size(
+                    exec_times,
+                    self.config.scale_factor,
+                )
 
             result.total_time = total_execution_time
             result.end_time = datetime.now().isoformat()

benchbox/core/tpch/queries.py

@@ -116,14 +116,9 @@ class QGenBinary:
 
     def _find_templates_dir(self) -> Path:
         """Find the TPC-H templates directory (queries, dists.dss, etc.)."""
-        # Always use the source directory for templates, regardless of binary location
-        import benchbox
-
-        package_root = Path(benchbox.__file__).parent.parent
-        templates_dir = package_root / "_sources/tpc-h/dbgen"
+        from benchbox.utils.tpc_compilation import get_tpc_templates_dir
 
-        if not templates_dir.exists():
-            raise RuntimeError(f"TPC-H templates directory not found at {templates_dir}")
+        templates_dir = get_tpc_templates_dir("tpc-h")
 
         # Verify required files and directories exist
         queries_dir = templates_dir / "queries"

benchbox/core/tpch/streams.py

@@ -108,26 +108,10 @@ class TPCHStreams(VerbosityMixin):
         # TPC-H query count (queries 1-22)
         self.query_count = 22
 
-        # Find TPC-H tools path
-        package_root = Path(__file__).parent.parent.parent.parent
-        self.tpch_tools_path = package_root / "_sources/tpc-h/dbgen"
+        # Find TPC-H templates path (queries, dists.dss, etc.)
+        from benchbox.utils.tpc_compilation import get_tpc_templates_dir
 
-        if not self.tpch_tools_path.exists():
-            # Try relative to the current file
-            self.tpch_tools_path = Path(__file__).parent.parent / "_sources/tpc-h/dbgen"
-
-            # Try with an absolute path based on the module location
-            if not self.tpch_tools_path.exists():
-                import benchbox
-
-                module_path = Path(benchbox.__file__).parent
-                self.tpch_tools_path = module_path / "_sources/tpc-h/dbgen"
-
-        if not self.tpch_tools_path.exists():
-            raise FileNotFoundError(
-                f"TPC-H tools not found at {self.tpch_tools_path}. "
-                "Please ensure the TPC-H sources are properly installed."
-            )
+        self.tpch_tools_path = get_tpc_templates_dir("tpc-h")
 
     def _compile_qgen(self, work_dir: Path) -> Path | None:
         """Compile the TPC-H qgen tool for query generation.

benchbox/core/transaction_primitives/benchmark.py

@@ -28,6 +28,9 @@ from benchbox.core.transaction_primitives.schema import STAGING_TABLES, get_all_
 from benchbox.utils.cloud_storage import create_path_handler
 from benchbox.utils.path_utils import get_benchmark_runs_datagen_path
 
+# DataFrame support - lazy import to avoid circular dependencies
+_dataframe_operations_module = None
+
 # Type alias for paths that could be local or cloud
 PathLike = Union[Path, "CloudPath", "DatabricksPath"]
 
@@ -1039,5 +1042,101 @@ class TransactionPrimitivesBenchmark(BaseBenchmark, OperationExecutor):
 
         return results
 
+    # =========================================================================
+    # DataFrame Support
+    # =========================================================================
+
+    def supports_dataframe_mode(self, platform_name: str) -> bool:
+        """Check if a platform supports DataFrame mode for Transaction Primitives.
+
+        Transaction Primitives requires ACID transaction support, which is only
+        available on certain DataFrame platforms with Delta Lake or Iceberg.
+
+        Args:
+            platform_name: Platform name to check
+
+        Returns:
+            True if platform supports DataFrame mode for transactions
+        """
+        global _dataframe_operations_module
+        if _dataframe_operations_module is None:
+            from benchbox.core.transaction_primitives import dataframe_operations
+
+            _dataframe_operations_module = dataframe_operations
+
+        is_valid, _ = _dataframe_operations_module.validate_transaction_primitives_platform(platform_name)
+        return is_valid
+
+    def get_dataframe_operations(self, platform_name: str, spark_session: Any = None) -> Any:
+        """Get DataFrame transaction operations manager for a platform.
+
+        This returns a DataFrameTransactionOperationsManager configured for
+        the specified platform, enabling ACID transaction benchmarking.
+
+        Args:
+            platform_name: Platform name (e.g., "pyspark-df", "delta-lake")
+            spark_session: SparkSession instance (required for pyspark-df)
+
+        Returns:
+            DataFrameTransactionOperationsManager instance
+
+        Raises:
+            ValueError: If platform does not support transactions
+        """
+        global _dataframe_operations_module
+        if _dataframe_operations_module is None:
+            from benchbox.core.transaction_primitives import dataframe_operations
+
+            _dataframe_operations_module = dataframe_operations
+
+        # Validate platform first
+        is_valid, error_msg = _dataframe_operations_module.validate_transaction_primitives_platform(platform_name)
+        if not is_valid:
+            raise ValueError(error_msg)
+
+        manager = _dataframe_operations_module.get_dataframe_transaction_manager(
+            platform_name, spark_session=spark_session
+        )
+
+        if manager is None:
+            raise ValueError(f"Could not create DataFrame transaction manager for {platform_name}")
+
+        return manager
+
+    def validate_dataframe_configuration(self, platform_name: str, spark_session: Any = None) -> tuple[bool, str]:
+        """Validate DataFrame configuration for Transaction Primitives.
+
+        This should be called during benchmark initialization to provide
+        early feedback when users attempt to run Transaction Primitives
+        on unsupported platforms.
+
+        Args:
+            platform_name: Platform name to validate
+            spark_session: SparkSession instance (for pyspark-df)
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        global _dataframe_operations_module
+        if _dataframe_operations_module is None:
+            from benchbox.core.transaction_primitives import dataframe_operations
+
+            _dataframe_operations_module = dataframe_operations
+
+        # First check if platform is potentially valid
+        is_valid, error_msg = _dataframe_operations_module.validate_transaction_primitives_platform(platform_name)
+        if not is_valid:
+            return False, error_msg
+
+        # For PySpark, check that SparkSession is provided
+        if "pyspark" in platform_name.lower() or "spark" in platform_name.lower():
+            if spark_session is None:
+                return False, (
+                    f"Platform '{platform_name}' requires a SparkSession for DataFrame operations.\n"
+                    f"Provide spark_session when initializing the platform adapter."
+                )
+
+        return True, ""
+
 
 __all__ = ["TransactionPrimitivesBenchmark", "OperationResult"]