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

sqlspec/statement/pipelines/__init__.py

@@ -12,56 +12,199 @@ Key Components:
 - `ValidationError`: Represents a single issue found during validation.
 """
 
-from sqlspec.statement.pipelines import analyzers, transformers, validators
-from sqlspec.statement.pipelines.analyzers import StatementAnalysis, StatementAnalyzer
-from sqlspec.statement.pipelines.base import ProcessorProtocol, SQLValidator, StatementPipeline
-from sqlspec.statement.pipelines.context import PipelineResult, SQLProcessingContext
-from sqlspec.statement.pipelines.result_types import AnalysisFinding, TransformationLog, ValidationError
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+import sqlglot
+from sqlglot import exp
+from typing_extensions import TypeVar
+
+from sqlspec.exceptions import RiskLevel
+from sqlspec.protocols import ProcessorProtocol
+from sqlspec.statement.pipelines.context import (
+    AnalysisFinding,
+    SQLProcessingContext,
+    TransformationLog,
+    ValidationError,
+)
 from sqlspec.statement.pipelines.transformers import (
-    CommentRemover,
+    CommentAndHintRemover,
     ExpressionSimplifier,
-    HintRemover,
     ParameterizeLiterals,
     SimplificationConfig,
 )
 from sqlspec.statement.pipelines.validators import (
     DMLSafetyConfig,
     DMLSafetyValidator,
+    ParameterStyleValidator,
     PerformanceConfig,
     PerformanceValidator,
+    SecurityValidator,
     SecurityValidatorConfig,
 )
+from sqlspec.utils.correlation import CorrelationContext
+from sqlspec.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from sqlspec.statement.parameters import ParameterInfo
+    from sqlspec.typing import SQLParameterType
+
 
 __all__ = (
-    # New Result Types
     "AnalysisFinding",
-    # Concrete Transformers
-    "CommentRemover",
-    # Concrete Validators
+    "CommentAndHintRemover",
     "DMLSafetyConfig",
     "DMLSafetyValidator",
     "ExpressionSimplifier",
-    "HintRemover",
+    "ParameterStyleValidator",
     "ParameterizeLiterals",
     "PerformanceConfig",
     "PerformanceValidator",
-    # Core Pipeline Components
     "PipelineResult",
     "ProcessorProtocol",
     "SQLProcessingContext",
-    # Base Validator
-    "SQLValidator",
+    "SecurityValidator",
     "SecurityValidatorConfig",
     "SimplificationConfig",
-    # Concrete Analyzers
-    "StatementAnalysis",
-    "StatementAnalyzer",
-    # Core Pipeline & Context
     "StatementPipeline",
     "TransformationLog",
     "ValidationError",
-    # Module exports
-    "analyzers",
-    "transformers",
-    "validators",
 )
+
+logger = get_logger("pipelines")
+
+ExpressionT = TypeVar("ExpressionT", bound="exp.Expression")
+ResultT = TypeVar("ResultT")
+
+
+# Import from context module to avoid duplication
+
+
+@dataclass
+class PipelineResult:
+    """Final result of pipeline execution."""
+
+    expression: exp.Expression
+    """The SQL expression after all transformations."""
+
+    context: SQLProcessingContext
+    """Contains all collected results."""
+
+    @property
+    def validation_errors(self) -> list[ValidationError]:
+        """Get validation errors from context."""
+        return self.context.validation_errors
+
+    @property
+    def has_errors(self) -> bool:
+        """Check if any validation errors exist."""
+        return self.context.has_errors
+
+    @property
+    def risk_level(self) -> RiskLevel:
+        """Get overall risk level."""
+        return self.context.risk_level
+
+    @property
+    def merged_parameters(self) -> "SQLParameterType":
+        """Get merged parameters from context."""
+        return self.context.merged_parameters
+
+    @property
+    def parameter_info(self) -> "list[ParameterInfo]":
+        """Get parameter info from context."""
+        return self.context.parameter_info
+
+
+class StatementPipeline:
+    """Orchestrates the processing of an SQL expression through transformers, validators, and analyzers."""
+
+    def __init__(
+        self,
+        transformers: Optional[list[ProcessorProtocol]] = None,
+        validators: Optional[list[ProcessorProtocol]] = None,
+        analyzers: Optional[list[ProcessorProtocol]] = None,
+    ) -> None:
+        self.transformers = transformers or []
+        self.validators = validators or []
+        self.analyzers = analyzers or []
+
+    def _run_processors(
+        self,
+        processors: list[ProcessorProtocol],
+        context: SQLProcessingContext,
+        processor_type: str,
+        enable_flag: bool,
+        error_risk_level: RiskLevel,
+    ) -> None:
+        if not enable_flag or context.current_expression is None:
+            return
+
+        for processor in processors:
+            processor_name = processor.__class__.__name__
+            try:
+                if processor_type == "transformer":
+                    context.current_expression = processor.process(context.current_expression, context)
+                else:
+                    processor.process(context.current_expression, context)
+            except Exception as e:
+                # In strict mode, re-raise validation exceptions
+                from sqlspec.exceptions import MissingParameterError
+                from sqlspec.statement.pipelines.validators._parameter_style import (
+                    MixedParameterStyleError,
+                    UnsupportedParameterStyleError,
+                )
+
+                if context.config.strict_mode and isinstance(
+                    e, (MissingParameterError, MixedParameterStyleError, UnsupportedParameterStyleError)
+                ):
+                    raise
+
+                error = ValidationError(
+                    message=f"{processor_type.capitalize()} {processor_name} failed: {e}",
+                    code=f"{processor_type}-failure",
+                    risk_level=error_risk_level,
+                    processor=processor_name,
+                    expression=context.current_expression,
+                )
+                context.validation_errors.append(error)
+                logger.exception("%s %s failed", processor_type.capitalize(), processor_name)
+                if processor_type == "transformer":
+                    break  # Stop further transformations if one fails
+
+    def execute_pipeline(self, context: "SQLProcessingContext") -> "PipelineResult":
+        """Executes the full pipeline (transform, validate, analyze) using the SQLProcessingContext."""
+        CorrelationContext.get()
+        if context.current_expression is None:
+            try:
+                context.current_expression = sqlglot.parse_one(context.initial_sql_string, dialect=context.dialect)
+            except Exception as e:
+                error = ValidationError(
+                    message=f"SQL Parsing Error: {e}",
+                    code="parsing-error",
+                    risk_level=RiskLevel.CRITICAL,
+                    processor="StatementPipeline",
+                    expression=None,
+                )
+                context.validation_errors.append(error)
+                return PipelineResult(expression=exp.Select(), context=context)
+
+        # Run transformers
+        if self.transformers:
+            self._run_processors(
+                self.transformers, context, "transformer", enable_flag=True, error_risk_level=RiskLevel.CRITICAL
+            )
+
+        # Run validators
+        if self.validators:
+            self._run_processors(
+                self.validators, context, "validator", enable_flag=True, error_risk_level=RiskLevel.CRITICAL
+            )
+
+        # Run analyzers
+        if self.analyzers:
+            self._run_processors(
+                self.analyzers, context, "analyzer", enable_flag=True, error_risk_level=RiskLevel.MEDIUM
+            )
+
+        return PipelineResult(expression=context.current_expression or exp.Select(), context=context)

sqlspec/statement/pipelines/analyzers/_analyzer.py

@@ -7,10 +7,11 @@ from typing import TYPE_CHECKING, Any, Optional
 from sqlglot import exp, parse_one
 from sqlglot.errors import ParseError as SQLGlotParseError
 
-from sqlspec.statement.pipelines.base import ProcessorProtocol
-from sqlspec.statement.pipelines.result_types import AnalysisFinding
+from sqlspec.protocols import ProcessorProtocol
+from sqlspec.statement.pipelines.context import AnalysisFinding
 from sqlspec.utils.correlation import CorrelationContext
 from sqlspec.utils.logging import get_logger
+from sqlspec.utils.type_guards import has_expressions
 
 if TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
@@ -146,7 +147,6 @@ class StatementAnalyzer(ProcessorProtocol):
 
         duration = time.perf_counter() - start_time
 
-        # Add analysis findings to context
         if analysis_result_obj.complexity_warnings:
             for warning in analysis_result_obj.complexity_warnings:
                 finding = AnalysisFinding(key="complexity_warning", value=warning, processor=self.__class__.__name__)
@@ -194,7 +194,6 @@ class StatementAnalyzer(ProcessorProtocol):
                 if expr is None:
                     expr = parse_one(sql_string, dialect=dialect)
 
-                # Check if the parsed expression is a valid SQL statement type
                 # Simple expressions like Alias or Identifier are not valid SQL statements
                 valid_statement_types = (
                     exp.Select,
@@ -230,7 +229,6 @@ class StatementAnalyzer(ProcessorProtocol):
         self, expression: exp.Expression, dialect: "DialectType" = None, config: "Optional[SQLConfig]" = None
     ) -> StatementAnalysis:
         """Analyze a SQLGlot expression directly, potentially using validation results for context."""
-        # Check cache first (using expression.sql() as key)
         # This caching needs to be context-aware if analysis depends on prior steps (e.g. validation_result)
         # For simplicity, let's assume for now direct expression analysis is cacheable if validation_result is not used deeply.
         cache_key = expression.sql()  # Simplified cache key
@@ -291,7 +289,7 @@ class StatementAnalyzer(ProcessorProtocol):
 
         for select in expression.find_all(exp.Select):
             from_clause = select.args.get("from")
-            if from_clause and hasattr(from_clause, "expressions") and len(from_clause.expressions) > 1:
+            if from_clause and has_expressions(from_clause) and len(from_clause.expressions) > 1:
                 # This logic checks for multiple tables in FROM without explicit JOINs
                 # It's a simplified check for potential cartesian products
                 cartesian_products += 1
@@ -324,11 +322,7 @@ class StatementAnalyzer(ProcessorProtocol):
     def _analyze_subqueries(self, expression: exp.Expression, analysis: StatementAnalysis) -> None:
         """Analyze subquery complexity and nesting depth."""
         subqueries: list[exp.Expression] = list(expression.find_all(exp.Subquery))
-        subqueries.extend(
-            query
-            for in_clause in expression.find_all(exp.In)
-            if (query := in_clause.args.get("query")) and isinstance(query, exp.Select)
-        )
+        # Workaround for EXISTS clauses: sqlglot doesn't wrap EXISTS subqueries in Subquery nodes
         subqueries.extend(
             [
                 exists_clause.this
@@ -346,7 +340,6 @@ class StatementAnalyzer(ProcessorProtocol):
             """Calculate the maximum depth of nested SELECT statements."""
             max_depth = 0
 
-            # Find all SELECT statements
             select_statements = list(expr.find_all(exp.Select))
 
             for select in select_statements:
@@ -354,7 +347,6 @@ class StatementAnalyzer(ProcessorProtocol):
                 depth = 0
                 current = select.parent
                 while current:
-                    # Check if parent is a SELECT or if it's inside a SELECT via Subquery/IN/EXISTS
                     if isinstance(current, exp.Select):
                         depth += 1
                     elif isinstance(current, (exp.Subquery, exp.In, exp.Exists)):
@@ -481,18 +473,21 @@ class StatementAnalyzer(ProcessorProtocol):
     def _extract_primary_table_name(expr: exp.Expression) -> "Optional[str]":
         """Extract the primary table name from an expression."""
         if isinstance(expr, exp.Insert):
-            if expr.this and hasattr(expr.this, "this"):
-                # Handle schema.table cases
+            if expr.this:
                 table = expr.this
                 if isinstance(table, exp.Table):
                     return table.name
-                if hasattr(table, "name"):
+                if isinstance(table, (exp.Identifier, exp.Var)):
                     return str(table.name)
         elif isinstance(expr, (exp.Update, exp.Delete)):
             if expr.this:
-                return str(expr.this.name) if hasattr(expr.this, "name") else str(expr.this)
+                if isinstance(expr.this, (exp.Table, exp.Identifier, exp.Var)):
+                    return str(expr.this.name)
+                return str(expr.this)
         elif isinstance(expr, exp.Select) and (from_clause := expr.find(exp.From)) and from_clause.this:
-            return str(from_clause.this.name) if hasattr(from_clause.this, "name") else str(from_clause.this)
+            if isinstance(from_clause.this, (exp.Table, exp.Identifier, exp.Var)):
+                return str(from_clause.this.name)
+            return str(from_clause.this)
         return None
 
     @staticmethod
@@ -500,16 +495,19 @@ class StatementAnalyzer(ProcessorProtocol):
         """Extract column names from an expression."""
         columns: list[str] = []
         if isinstance(expr, exp.Insert):
-            if expr.this and hasattr(expr.this, "expressions"):
-                columns.extend(str(col_expr.name) for col_expr in expr.this.expressions if hasattr(col_expr, "name"))
+            if expr.this and has_expressions(expr.this):
+                columns.extend(
+                    str(col_expr.name)
+                    for col_expr in expr.this.expressions
+                    if isinstance(col_expr, (exp.Column, exp.Identifier, exp.Var))
+                )
         elif isinstance(expr, exp.Select):
-            # Extract selected columns
             for projection in expr.expressions:
                 if isinstance(projection, exp.Column):
                     columns.append(str(projection.name))
-                elif hasattr(projection, "alias") and projection.alias:
+                elif isinstance(projection, exp.Alias) and projection.alias:
                     columns.append(str(projection.alias))
-                elif hasattr(projection, "name"):
+                elif isinstance(projection, (exp.Identifier, exp.Var)):
                     columns.append(str(projection.name))
 
         return columns
@@ -519,7 +517,7 @@ class StatementAnalyzer(ProcessorProtocol):
         """Extract all table names referenced in the expression."""
         tables: list[str] = []
         for table in expr.find_all(exp.Table):
-            if hasattr(table, "name"):
+            if isinstance(table, exp.Table):
                 table_name = str(table.name)
                 if table_name not in tables:
                     tables.append(table_name)
@@ -567,7 +565,6 @@ class StatementAnalyzer(ProcessorProtocol):
         # but exclude those within CTEs
         select_statements = []
         for select in expr.find_all(exp.Select):
-            # Check if this SELECT is inside a CTE
             parent = select.parent
             is_in_cte = False
             while parent:

sqlspec/statement/pipelines/context.py

@@ -4,16 +4,45 @@ from typing import TYPE_CHECKING, Any, Optional
 from sqlglot import exp
 
 from sqlspec.exceptions import RiskLevel
-from sqlspec.statement.pipelines.result_types import AnalysisFinding, TransformationLog, ValidationError
 
 if TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
 
-    from sqlspec.statement.parameters import ParameterInfo
+    from sqlspec.statement.parameters import ParameterInfo, ParameterNormalizationState
     from sqlspec.statement.sql import SQLConfig
     from sqlspec.typing import SQLParameterType
 
-__all__ = ("PipelineResult", "SQLProcessingContext")
+__all__ = ("AnalysisFinding", "SQLProcessingContext", "TransformationLog", "ValidationError")
+
+
+@dataclass
+class ValidationError:
+    """A specific validation issue found during processing."""
+
+    message: str
+    code: str  # e.g., "risky-delete", "missing-where"
+    risk_level: "RiskLevel"
+    processor: str  # Which processor found it
+    expression: "Optional[exp.Expression]" = None  # Problematic sub-expression
+
+
+@dataclass
+class TransformationLog:
+    """Record of a transformation applied."""
+
+    description: str
+    processor: str
+    before: Optional[str] = None  # SQL before transform
+    after: Optional[str] = None  # SQL after transform
+
+
+@dataclass
+class AnalysisFinding:
+    """Metadata discovered during analysis."""
+
+    key: str  # e.g., "complexity_score", "table_count"
+    value: Any
+    processor: str
 
 
 @dataclass
@@ -70,6 +99,9 @@ class SQLProcessingContext:
     extra_info: dict[str, Any] = field(default_factory=dict)
     """Extra information from parameter processing, including normalization state."""
 
+    parameter_normalization: "Optional[ParameterNormalizationState]" = None
+    """Single source of truth for parameter normalization tracking."""
+
     @property
     def has_errors(self) -> bool:
         """Check if any validation errors exist."""
@@ -81,39 +113,3 @@ class SQLProcessingContext:
         if not self.validation_errors:
             return RiskLevel.SAFE
         return max(error.risk_level for error in self.validation_errors)
-
-
-@dataclass
-class PipelineResult:
-    """Final result of pipeline execution."""
-
-    expression: exp.Expression
-    """The SQL expression after all transformations."""
-
-    context: SQLProcessingContext
-    """Contains all collected results."""
-
-    @property
-    def validation_errors(self) -> list[ValidationError]:
-        """Get validation errors from context."""
-        return self.context.validation_errors
-
-    @property
-    def has_errors(self) -> bool:
-        """Check if any validation errors exist."""
-        return self.context.has_errors
-
-    @property
-    def risk_level(self) -> RiskLevel:
-        """Get overall risk level."""
-        return self.context.risk_level
-
-    @property
-    def merged_parameters(self) -> "SQLParameterType":
-        """Get merged parameters from context."""
-        return self.context.merged_parameters
-
-    @property
-    def parameter_info(self) -> "list[ParameterInfo]":
-        """Get parameter info from context."""
-        return self.context.parameter_info

sqlspec/statement/pipelines/transformers/__init__.py

@@ -2,7 +2,6 @@
 
 from sqlspec.statement.pipelines.transformers._expression_simplifier import ExpressionSimplifier, SimplificationConfig
 from sqlspec.statement.pipelines.transformers._literal_parameterizer import ParameterizeLiterals
-from sqlspec.statement.pipelines.transformers._remove_comments import CommentRemover
-from sqlspec.statement.pipelines.transformers._remove_hints import HintRemover
+from sqlspec.statement.pipelines.transformers._remove_comments_and_hints import CommentAndHintRemover
 
-__all__ = ("CommentRemover", "ExpressionSimplifier", "HintRemover", "ParameterizeLiterals", "SimplificationConfig")
+__all__ = ("CommentAndHintRemover", "ExpressionSimplifier", "ParameterizeLiterals", "SimplificationConfig")