sqlspec 0.13.1__py3-none-any.whl → 0.16.2__py3-none-any.whl

sqlspec/statement/pipelines/context.py

@@ -1,115 +0,0 @@
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Optional
-
-from sqlglot import exp
-
-from sqlspec.exceptions import RiskLevel
-
-if TYPE_CHECKING:
-    from sqlglot.dialects.dialect import DialectType
-
-    from sqlspec.statement.parameters import ParameterInfo, ParameterNormalizationState
-    from sqlspec.statement.sql import SQLConfig
-    from sqlspec.typing import SQLParameterType
-
-__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
-class SQLProcessingContext:
-    """Carries expression through pipeline and collects all results."""
-
-    # Input
-    initial_sql_string: str
-    """The original SQL string input by the user."""
-
-    dialect: "DialectType"
-    """The SQL dialect to be used for parsing and generation."""
-
-    config: "SQLConfig"
-    """The configuration for SQL processing for this statement."""
-
-    # Initial state
-    initial_expression: Optional[exp.Expression] = None
-    """The initial parsed expression (for diffing/auditing)."""
-
-    # Current state
-    current_expression: Optional[exp.Expression] = None
-    """The SQL expression, potentially modified by transformers."""
-
-    # Parameters
-    initial_parameters: "Optional[SQLParameterType]" = None
-    """The initial parameters as provided to the SQL object (before merging with kwargs)."""
-    initial_kwargs: "Optional[dict[str, Any]]" = None
-    """The initial keyword arguments as provided to the SQL object."""
-    merged_parameters: "SQLParameterType" = field(default_factory=list)
-    """Parameters after merging initial_parameters and initial_kwargs."""
-    parameter_info: "list[ParameterInfo]" = field(default_factory=list)
-    """Information about identified parameters in the initial_sql_string."""
-    extracted_parameters_from_pipeline: list[Any] = field(default_factory=list)
-    """List of parameters extracted by transformers (e.g., ParameterizeLiterals)."""
-
-    # Collected results (processors append to these)
-    validation_errors: list[ValidationError] = field(default_factory=list)
-    """Validation errors found during processing."""
-    analysis_findings: list[AnalysisFinding] = field(default_factory=list)
-    """Analysis findings discovered during processing."""
-    transformations: list[TransformationLog] = field(default_factory=list)
-    """Transformations applied during processing."""
-
-    # General metadata
-    metadata: dict[str, Any] = field(default_factory=dict)
-    """General-purpose metadata store."""
-
-    # Flags
-    input_sql_had_placeholders: bool = False
-    """Flag indicating if the initial_sql_string already contained placeholders."""
-    statement_type: Optional[str] = None
-    """The detected type of the SQL statement (e.g., SELECT, INSERT, DDL)."""
-    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."""
-        return bool(self.validation_errors)
-
-    @property
-    def risk_level(self) -> RiskLevel:
-        """Calculate overall risk from validation errors."""
-        if not self.validation_errors:
-            return RiskLevel.SAFE
-        return max(error.risk_level for error in self.validation_errors)

sqlspec/statement/pipelines/transformers/__init__.py

@@ -1,7 +0,0 @@
-"""SQL Transformers for the processing pipeline."""
-
-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_and_hints import CommentAndHintRemover
-
-__all__ = ("CommentAndHintRemover", "ExpressionSimplifier", "ParameterizeLiterals", "SimplificationConfig")

sqlspec/statement/pipelines/transformers/_expression_simplifier.py

@@ -1,88 +0,0 @@
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, cast
-
-from sqlglot.optimizer import simplify
-
-from sqlspec.exceptions import RiskLevel
-from sqlspec.statement.pipelines import ProcessorProtocol, TransformationLog, ValidationError
-
-if TYPE_CHECKING:
-    from sqlglot import exp
-
-    from sqlspec.statement.pipelines import SQLProcessingContext
-
-__all__ = ("ExpressionSimplifier", "SimplificationConfig")
-
-
-@dataclass
-class SimplificationConfig:
-    """Configuration for expression simplification."""
-
-    enable_literal_folding: bool = True
-    enable_boolean_optimization: bool = True
-    enable_connector_optimization: bool = True
-    enable_equality_normalization: bool = True
-    enable_complement_removal: bool = True
-
-
-class ExpressionSimplifier(ProcessorProtocol):
-    """Advanced expression optimization using SQLGlot's simplification engine."""
-
-    def __init__(self, enabled: bool = True, config: Optional[SimplificationConfig] = None) -> None:
-        self.enabled = enabled
-        self.config = config or SimplificationConfig()
-
-    def process(
-        self, expression: "Optional[exp.Expression]", context: "SQLProcessingContext"
-    ) -> "Optional[exp.Expression]":
-        if not self.enabled or expression is None:
-            return expression
-
-        original_sql = expression.sql(dialect=context.dialect)
-
-        try:
-            simplified = simplify.simplify(
-                expression.copy(), constant_propagation=self.config.enable_literal_folding, dialect=context.dialect
-            )
-        except Exception as e:
-            error = ValidationError(
-                message=f"Expression simplification failed: {e}",
-                code="simplification-failed",
-                risk_level=RiskLevel.LOW,
-                processor=self.__class__.__name__,
-                expression=expression,
-            )
-            context.validation_errors.append(error)
-            return expression
-        else:
-            simplified_sql = simplified.sql(dialect=context.dialect)
-            chars_saved = len(original_sql) - len(simplified_sql)
-
-            if original_sql != simplified_sql:
-                log = TransformationLog(
-                    description=f"Simplified expression (saved {chars_saved} chars)",
-                    processor=self.__class__.__name__,
-                    before=original_sql,
-                    after=simplified_sql,
-                )
-                context.transformations.append(log)
-
-            optimizations = []
-            if self.config.enable_literal_folding:
-                optimizations.append("literal_folding")
-            if self.config.enable_boolean_optimization:
-                optimizations.append("boolean_optimization")
-            if self.config.enable_connector_optimization:
-                optimizations.append("connector_optimization")
-            if self.config.enable_equality_normalization:
-                optimizations.append("equality_normalization")
-            if self.config.enable_complement_removal:
-                optimizations.append("complement_removal")
-
-            context.metadata[self.__class__.__name__] = {
-                "simplified": original_sql != simplified_sql,
-                "chars_saved": chars_saved,
-                "optimizations_applied": optimizations,
-            }
-
-            return cast("exp.Expression", simplified)