sqlspec 0.12.2__py3-none-any.whl → 0.13.0__py3-none-any.whl

sqlspec/statement/pipelines/transformers/_remove_comments_and_hints.py

@@ -0,0 +1,76 @@
+"""Removes SQL comments and hints from expressions."""
+
+from typing import TYPE_CHECKING, Optional
+
+from sqlglot import exp
+
+from sqlspec.protocols import ProcessorProtocol
+
+if TYPE_CHECKING:
+    from sqlspec.statement.pipelines.context import SQLProcessingContext
+
+__all__ = ("CommentAndHintRemover",)
+
+
+class CommentAndHintRemover(ProcessorProtocol):
+    """Removes SQL comments and hints from expressions using SQLGlot's AST traversal."""
+
+    def __init__(self, enabled: bool = True, remove_comments: bool = True, remove_hints: bool = False) -> None:
+        self.enabled = enabled
+        self.remove_comments = remove_comments
+        self.remove_hints = remove_hints
+
+    def process(
+        self, expression: "Optional[exp.Expression]", context: "SQLProcessingContext"
+    ) -> "Optional[exp.Expression]":
+        if not self.enabled or expression is None:
+            return expression
+
+        comments_removed_count = 0
+        hints_removed_count = 0
+
+        def _remove_comments_and_hints(node: exp.Expression) -> "Optional[exp.Expression]":
+            nonlocal comments_removed_count, hints_removed_count
+
+            if self.remove_hints and isinstance(node, exp.Hint):
+                hints_removed_count += 1
+                return None
+
+            if hasattr(node, "comments") and node.comments:
+                original_comment_count = len(node.comments)
+                comments_to_keep = []
+                for comment in node.comments:
+                    comment_text = str(comment).strip()
+                    is_hint = self._is_hint(comment_text)
+
+                    if is_hint:
+                        if not self.remove_hints:
+                            comments_to_keep.append(comment)
+                    elif not self.remove_comments:
+                        comments_to_keep.append(comment)
+
+                removed_count = original_comment_count - len(comments_to_keep)
+                if removed_count > 0:
+                    if self.remove_hints:
+                        hints_removed_count += sum(1 for c in node.comments if self._is_hint(str(c).strip()))
+                    if self.remove_comments:
+                        comments_removed_count += sum(1 for c in node.comments if not self._is_hint(str(c).strip()))
+
+                    node.pop_comments()
+                    if comments_to_keep:
+                        node.add_comments(comments_to_keep)
+
+            return node
+
+        cleaned_expression = expression.transform(_remove_comments_and_hints, copy=True)
+
+        context.metadata["comments_removed"] = comments_removed_count
+        context.metadata["hints_removed"] = hints_removed_count
+
+        return cleaned_expression
+
+    def _is_hint(self, comment_text: str) -> bool:
+        hint_keywords = ["INDEX", "USE_NL", "USE_HASH", "PARALLEL", "FULL", "FIRST_ROWS", "ALL_ROWS"]
+        return any(keyword in comment_text.upper() for keyword in hint_keywords) or (
+            comment_text.startswith("!") and comment_text.endswith("")
+        )

sqlspec/statement/pipelines/validators/_dml_safety.py

@@ -6,7 +6,8 @@ from typing import TYPE_CHECKING, Optional
 from sqlglot import expressions as exp
 
 from sqlspec.exceptions import RiskLevel
-from sqlspec.statement.pipelines.validators.base import BaseValidator
+from sqlspec.protocols import ProcessorProtocol
+from sqlspec.statement.pipelines.context import ValidationError
 
 if TYPE_CHECKING:
     from sqlspec.statement.pipelines.context import SQLProcessingContext
@@ -36,7 +37,7 @@ class DMLSafetyConfig:
     max_affected_rows: "Optional[int]" = None  # Limit for DML operations
 
 
-class DMLSafetyValidator(BaseValidator):
+class DMLSafetyValidator(ProcessorProtocol):
     """Unified validator for DML/DDL safety checks.
 
     This validator consolidates:
@@ -52,9 +53,31 @@ class DMLSafetyValidator(BaseValidator):
         Args:
             config: Configuration for safety validation
         """
-        super().__init__()
         self.config = config or DMLSafetyConfig()
 
+    def process(
+        self, expression: "Optional[exp.Expression]", context: "SQLProcessingContext"
+    ) -> "Optional[exp.Expression]":
+        """Process the expression for validation (implements ProcessorProtocol)."""
+        if expression is None:
+            return None
+        self.validate(expression, context)
+        return expression
+
+    def add_error(
+        self,
+        context: "SQLProcessingContext",
+        message: str,
+        code: str,
+        risk_level: RiskLevel,
+        expression: "Optional[exp.Expression]" = None,
+    ) -> None:
+        """Add a validation error to the context."""
+        error = ValidationError(
+            message=message, code=code, risk_level=risk_level, processor=self.__class__.__name__, expression=expression
+        )
+        context.validation_errors.append(error)
+
     def validate(self, expression: "exp.Expression", context: "SQLProcessingContext") -> None:
         """Validate SQL statement for safety issues.
 
@@ -66,7 +89,6 @@ class DMLSafetyValidator(BaseValidator):
         category = self._categorize_statement(expression)
         operation = self._get_operation_type(expression)
 
-        # Check DDL restrictions
         if category == StatementCategory.DDL and self.config.prevent_ddl:
             if operation not in self.config.allowed_ddl_operations:
                 self.add_error(
@@ -77,7 +99,6 @@ class DMLSafetyValidator(BaseValidator):
                     expression=expression,
                 )
 
-        # Check DML safety
         elif category == StatementCategory.DML:
             if operation in self.config.require_where_clause and not self._has_where_clause(expression):
                 self.add_error(
@@ -88,7 +109,6 @@ class DMLSafetyValidator(BaseValidator):
                     expression=expression,
                 )
 
-            # Check affected row limits
             if self.config.max_affected_rows:
                 estimated_rows = self._estimate_affected_rows(expression)
                 if estimated_rows > self.config.max_affected_rows:
@@ -100,7 +120,6 @@ class DMLSafetyValidator(BaseValidator):
                         expression=expression,
                     )
 
-        # Check DCL restrictions
         elif category == StatementCategory.DCL and self.config.prevent_dcl:
             self.add_error(
                 context,
@@ -187,10 +206,8 @@ class DMLSafetyValidator(BaseValidator):
 
         where = expression.args.get("where")
         if where:
-            # Check for primary key or unique conditions
             if self._has_unique_condition(where):
                 return 1
-            # Check for indexed conditions
             if self._has_indexed_condition(where):
                 return 100  # Rough estimate
 
@@ -230,8 +247,10 @@ class DMLSafetyValidator(BaseValidator):
             return False
         # Look for common indexed column patterns
         for condition in where.find_all(exp.Predicate):
-            if hasattr(condition, "left") and isinstance(condition.left, exp.Column):  # pyright: ignore
-                col_name = condition.left.name.lower()  # pyright: ignore
+            if isinstance(condition, (exp.EQ, exp.GT, exp.GTE, exp.LT, exp.LTE, exp.NEQ)) and isinstance(
+                condition.left, exp.Column
+            ):
+                col_name = condition.left.name.lower()
                 # Common indexed columns
                 if col_name in {"created_at", "updated_at", "email", "username", "status", "type"}:
                     return True
@@ -251,20 +270,16 @@ class DMLSafetyValidator(BaseValidator):
 
         # For DML statements
         if isinstance(expression, (exp.Insert, exp.Update, exp.Delete)):
-            if hasattr(expression, "this") and expression.this:
+            if expression.this:
                 table_expr = expression.this
                 if isinstance(table_expr, exp.Table):
                     tables.append(table_expr.name)
 
         # For DDL statements
-        elif (
-            isinstance(expression, (exp.Create, exp.Drop, exp.Alter))
-            and hasattr(expression, "this")
-            and expression.this
-        ):
+        elif isinstance(expression, (exp.Create, exp.Drop, exp.Alter)) and expression.this:
             # For CREATE TABLE, the table is in expression.this.this
             if isinstance(expression, exp.Create) and isinstance(expression.this, exp.Schema):
-                if hasattr(expression.this, "this") and expression.this.this:
+                if expression.this.this:
                     table_expr = expression.this.this
                     if isinstance(table_expr, exp.Table):
                         tables.append(table_expr.name)

sqlspec/statement/pipelines/validators/_parameter_style.py

@@ -6,9 +6,9 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 from sqlglot import exp
 
 from sqlspec.exceptions import MissingParameterError, RiskLevel, SQLValidationError
-from sqlspec.statement.pipelines.base import ProcessorProtocol
-from sqlspec.statement.pipelines.result_types import ValidationError
-from sqlspec.typing import is_dict
+from sqlspec.protocols import ProcessorProtocol
+from sqlspec.statement.pipelines.context import ValidationError
+from sqlspec.utils.type_guards import is_dict
 
 if TYPE_CHECKING:
     from sqlspec.statement.pipelines.context import SQLProcessingContext
@@ -73,12 +73,15 @@ class ParameterStyleValidator(ProcessorProtocol):
             config = context.config
             param_info = context.parameter_info
 
-            # First check parameter styles if configured
+            # Check if parameters were normalized by looking for param_ placeholders
+            # This happens when Oracle numeric parameters (:1, :2) are normalized
+            is_normalized = param_info and any(p.name and p.name.startswith("param_") for p in param_info)
+
+            # First check parameter styles if configured (skip if normalized)
             has_style_errors = False
-            if config.allowed_parameter_styles is not None and param_info:
+            if not is_normalized and config.allowed_parameter_styles is not None and param_info:
                 unique_styles = {p.style for p in param_info}
 
-                # Check for mixed styles first (before checking individual styles)
                 if len(unique_styles) > 1 and not config.allow_mixed_parameter_styles:
                     detected_style_strs = [str(s) for s in unique_styles]
                     detected_styles = ", ".join(sorted(detected_style_strs))
@@ -95,7 +98,6 @@ class ParameterStyleValidator(ProcessorProtocol):
                     context.validation_errors.append(error)
                     has_style_errors = True
 
-                # Check for disallowed styles
                 disallowed_styles = {str(s) for s in unique_styles if not config.validate_parameter_style(s)}
                 if disallowed_styles:
                     disallowed_str = ", ".join(sorted(disallowed_styles))
@@ -276,13 +278,84 @@ class ParameterStyleValidator(ProcessorProtocol):
     ) -> None:
         """Handle validation for named parameters."""
         missing: list[str] = []
-        for p in param_info:
-            param_name = p.name
-            if param_name not in merged_params:
-                is_synthetic = any(key.startswith(("_arg_", "param_")) for key in merged_params)
-                is_named_style = p.style.value not in {"qmark", "numeric"}
-                if (not is_synthetic or is_named_style) and param_name:
-                    missing.append(param_name)
+
+        # Check if we have normalized parameters (e.g., param_0)
+        is_normalized = any(p.name and p.name.startswith("param_") for p in param_info)
+
+        if is_normalized and hasattr(context, "extra_info"):
+            # For normalized parameters, we need to check against the original placeholder mapping
+            placeholder_map = context.extra_info.get("placeholder_map", {})
+
+            # Check if we have Oracle numeric keys in merged_params
+            all_numeric_keys = all(key.isdigit() for key in merged_params)
+
+            if all_numeric_keys:
+                # Parameters were provided as list and converted to Oracle numeric dict {"1": val1, "2": val2}
+                for i, _p in enumerate(param_info):
+                    normalized_name = f"param_{i}"
+                    original_key = placeholder_map.get(normalized_name)
+
+                    if original_key is not None:
+                        # Check using the original key (e.g., "1", "2" for Oracle)
+                        original_key_str = str(original_key)
+                        if original_key_str not in merged_params or merged_params[original_key_str] is None:
+                            if original_key_str.isdigit():
+                                missing.append(f":{original_key}")
+                            else:
+                                missing.append(f":{original_key}")
+            else:
+                # Check if all params follow param_N pattern
+                all_param_keys = all(key.startswith("param_") and key[6:].isdigit() for key in merged_params)
+
+                if all_param_keys:
+                    # This was originally a list converted to dict with param_N keys
+                    for i, _p in enumerate(param_info):
+                        normalized_name = f"param_{i}"
+                        if normalized_name not in merged_params or merged_params[normalized_name] is None:
+                            # Get original parameter style from placeholder map
+                            original_key = placeholder_map.get(normalized_name)
+                            if original_key is not None:
+                                original_key_str = str(original_key)
+                                if original_key_str.isdigit():
+                                    missing.append(f":{original_key}")
+                                else:
+                                    missing.append(f":{original_key}")
+                else:
+                    # Mixed parameter names, check using placeholder map
+                    for i, _p in enumerate(param_info):
+                        normalized_name = f"param_{i}"
+                        original_key = placeholder_map.get(normalized_name)
+
+                        if original_key is not None:
+                            # For mixed params, check both normalized and original keys
+                            original_key_str = str(original_key)
+
+                            # First check with normalized name
+                            found = normalized_name in merged_params and merged_params[normalized_name] is not None
+
+                            # If not found, check with original key
+                            if not found:
+                                found = (
+                                    original_key_str in merged_params and merged_params[original_key_str] is not None
+                                )
+
+                            if not found:
+                                # Format the missing parameter based on original style
+                                if original_key_str.isdigit():
+                                    # It was an Oracle numeric parameter (e.g., :1)
+                                    missing.append(f":{original_key}")
+                                else:
+                                    # It was a named parameter (e.g., :status)
+                                    missing.append(f":{original_key}")
+        else:
+            # Regular parameter validation
+            for p in param_info:
+                param_name = p.name
+                if param_name not in merged_params or merged_params.get(param_name) is None:
+                    is_synthetic = any(key.startswith(("arg_", "param_")) for key in merged_params)
+                    is_named_style = p.style.value not in {"qmark", "numeric"}
+                    if (not is_synthetic or is_named_style) and param_name:
+                        missing.append(param_name)
 
         if missing:
             msg = f"Missing required parameters: {', '.join(missing)}"

sqlspec/statement/pipelines/validators/_performance.py

@@ -18,7 +18,9 @@ from sqlglot.optimizer import (
 )
 
 from sqlspec.exceptions import RiskLevel
-from sqlspec.statement.pipelines.validators.base import BaseValidator
+from sqlspec.protocols import ProcessorProtocol
+from sqlspec.statement.pipelines.context import ValidationError
+from sqlspec.utils.type_guards import has_expressions
 
 if TYPE_CHECKING:
     from sqlspec.statement.pipelines.context import SQLProcessingContext
@@ -126,7 +128,7 @@ class PerformanceAnalysis:
     potential_improvement: float = 0.0
 
 
-class PerformanceValidator(BaseValidator):
+class PerformanceValidator(ProcessorProtocol):
     """Comprehensive query performance validator.
 
     Validates query performance by detecting:
@@ -143,9 +145,31 @@ class PerformanceValidator(BaseValidator):
         Args:
             config: Configuration for performance validation
         """
-        super().__init__()
         self.config = config or PerformanceConfig()
 
+    def process(
+        self, expression: "Optional[exp.Expression]", context: "SQLProcessingContext"
+    ) -> "Optional[exp.Expression]":
+        """Process the expression for validation (implements ProcessorProtocol)."""
+        if expression is None:
+            return None
+        self.validate(expression, context)
+        return expression
+
+    def add_error(
+        self,
+        context: "SQLProcessingContext",
+        message: str,
+        code: str,
+        risk_level: RiskLevel,
+        expression: "Optional[exp.Expression]" = None,
+    ) -> None:
+        """Add a validation error to the context."""
+        error = ValidationError(
+            message=message, code=code, risk_level=risk_level, processor=self.__class__.__name__, expression=expression
+        )
+        context.validation_errors.append(error)
+
     def validate(self, expression: "exp.Expression", context: "SQLProcessingContext") -> None:
         """Validate SQL statement for performance issues.
 
@@ -167,7 +191,6 @@ class PerformanceValidator(BaseValidator):
         if self.config.enable_optimization_analysis:
             self._analyze_optimization_opportunities(expression, analysis, context)
 
-        # Check for cartesian products
         if self.config.warn_on_cartesian:
             cartesian_issues = self._check_cartesian_products(analysis)
             for issue in cartesian_issues:
@@ -179,7 +202,6 @@ class PerformanceValidator(BaseValidator):
                     expression=expression,
                 )
 
-        # Check join complexity
         if analysis.join_count > self.config.max_joins:
             self.add_error(
                 context,
@@ -189,7 +211,6 @@ class PerformanceValidator(BaseValidator):
                 expression=expression,
             )
 
-        # Check subquery depth
         if analysis.max_subquery_depth > self.config.max_subqueries:
             self.add_error(
                 context,
@@ -213,7 +234,6 @@ class PerformanceValidator(BaseValidator):
         # Calculate overall complexity score
         complexity_score = self._calculate_complexity(analysis)
 
-        # Build metadata
         context.metadata[self.__class__.__name__] = {
             "complexity_score": complexity_score,
             "join_analysis": {
@@ -260,7 +280,6 @@ class PerformanceValidator(BaseValidator):
             analysis.current_subquery_depth = max(analysis.current_subquery_depth, depth + 1)
             analysis.max_subquery_depth = max(analysis.max_subquery_depth, analysis.current_subquery_depth)
 
-            # Check if correlated
             if self._is_correlated_subquery(expr):
                 analysis.correlated_subqueries += 1
 
@@ -270,7 +289,6 @@ class PerformanceValidator(BaseValidator):
             join_type = expr.args.get("kind", "INNER").upper()
             analysis.join_types[join_type] = analysis.join_types.get(join_type, 0) + 1
 
-            # Extract join condition
             condition = expr.args.get("on")
             left_table = self._get_table_name(expr.parent) if expr.parent else "unknown"
             right_table = self._get_table_name(expr.this)
@@ -287,10 +305,10 @@ class PerformanceValidator(BaseValidator):
             analysis.where_conditions += len(list(expr.find_all(exp.Predicate)))
 
         elif isinstance(expr, exp.Group):
-            analysis.group_by_columns += len(expr.expressions) if hasattr(expr, "expressions") else 0
+            analysis.group_by_columns += len(expr.expressions) if has_expressions(expr) else 0
 
         elif isinstance(expr, exp.Order):
-            analysis.order_by_columns += len(expr.expressions) if hasattr(expr, "expressions") else 0
+            analysis.order_by_columns += len(expr.expressions) if has_expressions(expr) else 0
 
         elif isinstance(expr, exp.Distinct):
             analysis.distinct_operations += 1
@@ -302,13 +320,15 @@ class PerformanceValidator(BaseValidator):
             analysis.select_star_count += 1
 
         # Recursive traversal
-        for child in expr.args.values():
-            if isinstance(child, exp.Expression):
-                self._analyze_expression(child, analysis, depth)
-            elif isinstance(child, list):
-                for item in child:
-                    if isinstance(item, exp.Expression):
-                        self._analyze_expression(item, analysis, depth)
+        expr_args = getattr(expr, "args", None)
+        if expr_args is not None and isinstance(expr_args, dict):
+            for child in expr_args.values():
+                if isinstance(child, exp.Expression):
+                    self._analyze_expression(child, analysis, depth)
+                elif isinstance(child, list):
+                    for item in child:
+                        if isinstance(item, exp.Expression):
+                            self._analyze_expression(item, analysis, depth)
 
     def _check_cartesian_products(self, analysis: PerformanceAnalysis) -> "list[PerformanceIssue]":
         """Detect potential cartesian products from join analysis.
@@ -335,11 +355,9 @@ class PerformanceValidator(BaseValidator):
                     )
                 )
             else:
-                # Build join graph
                 join_graph[condition.left_table].add(condition.right_table)
                 join_graph[condition.right_table].add(condition.left_table)
 
-        # Check for disconnected tables (implicit cartesian)
         if len(analysis.tables) > 1:
             connected = self._find_connected_components(join_graph, analysis.tables)
             if len(connected) > 1:
@@ -595,7 +613,6 @@ class PerformanceValidator(BaseValidator):
 
             for opt_type, optimizer, description in optimizations:
                 try:
-                    # Apply the optimization
                     optimized = optimizer(expression.copy(), dialect=context.dialect)  # type: ignore[operator]
 
                     if optimized is None:
@@ -623,7 +640,6 @@ class PerformanceValidator(BaseValidator):
                     else:
                         improvement = 0.0
 
-                    # Only add if improvement meets threshold
                     if improvement >= self.config.optimization_threshold:
                         opportunities.append(
                             OptimizationOpportunity(
@@ -636,7 +652,6 @@ class PerformanceValidator(BaseValidator):
                             )
                         )
 
-                        # Update the best optimization if this is better
                         if improvement > cumulative_improvement:
                             best_optimized = optimized
                             cumulative_improvement = improvement