sql-dialect-master 1.1.1__py3-none-any.whl

backend/core/exceptions.py

@@ -0,0 +1,124 @@
+"""Custom exceptions for SQL Dialect Master.
+
+Provides a hierarchy of exceptions for better error handling and debugging.
+"""
+from enum import Enum
+
+
+class ErrorCode(str, Enum):
+    """Stable machine-readable error categories."""
+    UNSUPPORTED_DIALECT = "UNSUPPORTED_DIALECT"
+    TRANSPILE_FAILED = "TRANSPILE_FAILED"
+    PARSE_FAILED = "PARSE_FAILED"
+    SECURITY_VIOLATION = "SECURITY_VIOLATION"
+    VALIDATION_FAILED = "VALIDATION_FAILED"
+    BAD_REQUEST = "BAD_REQUEST"
+    NOT_FOUND = "NOT_FOUND"
+    METHOD_NOT_ALLOWED = "METHOD_NOT_ALLOWED"
+    PAYLOAD_TOO_LARGE = "PAYLOAD_TOO_LARGE"
+    RATE_LIMITED = "RATE_LIMITED"
+    CACHE_FAILED = "CACHE_FAILED"
+    CONFIGURATION_INVALID = "CONFIGURATION_INVALID"
+    RULE_CONFLICT = "RULE_CONFLICT"
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+    UNKNOWN = "UNKNOWN"
+
+
+class SDMException(Exception):
+    """Base exception for SQL Dialect Master."""
+
+    error_code = ErrorCode.UNKNOWN
+
+    def __init__(self, message: str, details: dict = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+
+    def to_dict(self) -> dict:
+        """Convert exception to a backward-compatible API error dictionary."""
+        code = self.error_code.value
+        return {
+            "error_type": self.__class__.__name__,
+            "error_code": code,
+            "code": code,
+            "message": self.message,
+            "details": self.details
+        }
+
+
+class UnsupportedDialectError(SDMException):
+    """Raised when an unsupported SQL dialect is specified."""
+
+    error_code = ErrorCode.UNSUPPORTED_DIALECT
+
+    def __init__(self, dialect: str, supported: list = None):
+        message = f"Unsupported dialect: {dialect}"
+        if supported:
+            message += f". Supported: {', '.join(supported)}"
+        super().__init__(message, {"dialect": dialect, "supported": supported})
+
+
+class TranspileError(SDMException):
+    """Raised when SQL transpilation fails."""
+
+    error_code = ErrorCode.TRANSPILE_FAILED
+
+    def __init__(self, message: str, source_sql: str = None, source_dialect: str = None, target_dialect: str = None):
+        details = {
+            "source_sql": source_sql[:200] if source_sql else None,
+            "source_dialect": source_dialect,
+            "target_dialect": target_dialect
+        }
+        super().__init__(message, details)
+
+
+class ParseError(SDMException):
+    """Raised when SQL parsing fails."""
+
+    error_code = ErrorCode.PARSE_FAILED
+
+    def __init__(self, message: str, sql: str = None, dialect: str = None):
+        details = {"sql": sql[:200] if sql else None, "dialect": dialect}
+        super().__init__(message, details)
+
+
+class SecurityViolationError(SDMException):
+    """Raised when SQL contains potentially dangerous patterns."""
+
+    error_code = ErrorCode.SECURITY_VIOLATION
+
+    def __init__(self, message: str, pattern: str = None):
+        details = {"pattern": pattern}
+        super().__init__(message, details)
+
+
+class ValidationError(SDMException):
+    """Raised when input validation fails."""
+
+    error_code = ErrorCode.VALIDATION_FAILED
+
+    def __init__(self, message: str, field: str = None, value: str = None):
+        details = {"field": field, "value": value}
+        super().__init__(message, details)
+
+
+class CacheError(SDMException):
+    """Raised when cache operations fail."""
+
+    error_code = ErrorCode.CACHE_FAILED
+
+
+class ConfigurationError(SDMException):
+    """Raised when configuration is invalid."""
+
+    error_code = ErrorCode.CONFIGURATION_INVALID
+
+
+class RuleConflictError(SDMException):
+    """Raised when transformation rules conflict."""
+
+    error_code = ErrorCode.RULE_CONFLICT
+
+    def __init__(self, message: str, rule1: str = None, rule2: str = None):
+        details = {"rule1": rule1, "rule2": rule2}
+        super().__init__(message, details)

backend/core/function_call_scanner.py

@@ -0,0 +1,64 @@
+"""Scanner-backed function-call replacement shared by custom SQL rewrites."""
+from __future__ import annotations
+
+from typing import Callable
+
+from .p1_sql_scanner import mask_non_executable
+
+
+def replace_function_calls(
+    sql: str,
+    function_name: str,
+    replacer: Callable[[str, str], str],
+) -> str:
+    """Replace complete calls without interpreting literals or comments as SQL."""
+    upper_name = function_name.upper()
+    name_len = len(function_name)
+    masked = mask_non_executable(sql)
+    result = []
+    i = 0
+    length = len(sql)
+
+    while i < length:
+        if masked[i:i + name_len].upper() != upper_name:
+            result.append(sql[i])
+            i += 1
+            continue
+
+        name_end = i + name_len
+        if i > 0 and (masked[i - 1].isalnum() or masked[i - 1] == "_"):
+            result.append(sql[i])
+            i += 1
+            continue
+
+        j = name_end
+        while j < length and masked[j].isspace():
+            j += 1
+        if j >= length or masked[j] != "(":
+            result.append(sql[i])
+            i += 1
+            continue
+
+        depth = 0
+        k = j
+        while k < length:
+            char = masked[k]
+            if char == "(":
+                depth += 1
+            elif char == ")":
+                depth -= 1
+                if depth == 0:
+                    original_call = sql[i:k + 1]
+                    args = sql[j + 1:k]
+                    result.append(replacer(args, original_call))
+                    i = k + 1
+                    break
+            k += 1
+        else:
+            result.append(sql[i:])
+            break
+
+    return "".join(result)
+
+
+__all__ = ["replace_function_calls"]

backend/core/function_semantics.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Semantics-aware function equivalence metadata for SQL dialect conversion.
+
+The existing function catalog answers "is there syntax for this function?".
+This module answers the stronger question "can this function be treated as
+semantically equivalent for this source/target dialect pair?".
+
+Only explicitly-reviewed functions and dialect pairs are classified as
+semantic equivalence. Unreviewed pairs remain ``unknown`` instead of being
+inferred from syntax availability or fuzzy matching.
+"""
+from typing import Any, Dict, Tuple
+
+
+FunctionKey = Tuple[str, str, str]
+
+
+_SEMANTIC_STATUS = {
+    "equivalent": "equivalent",
+    "supported-but-different": "supported-but-different",
+    "unsupported": "unsupported",
+    "unknown": "unknown",
+}
+
+
+# Explicit metadata for the initial high-risk cross-dialect corpus.
+# Keep this registry intentionally small: additions require semantic review and
+# a regression test rather than being inferred from functions_db.json syntax.
+_FUNCTION_SEMANTICS: Dict[str, Dict[str, Any]] = {
+    "DATEDIFF": {
+        "argument_semantics": "calendar-day difference; argument order and/or unit syntax is dialect-sensitive",
+        "return_shape": "scalar integer-like value",
+        "null_behavior": "NULL-sensitive; follows source/target function semantics",
+        "notes": "Dialect implementations differ in argument order and unit handling.",
+        "pairs": {
+            ("mysql", "tsql"): "supported-but-different",
+            ("mysql", "postgres"): "supported-but-different",
+        },
+    },
+    "DATE_FORMAT": {
+        "argument_semantics": "format a date/time value using dialect-specific format tokens",
+        "return_shape": "string",
+        "null_behavior": "NULL input produces NULL",
+        "notes": "Formatting token languages differ across dialects.",
+        "pairs": {
+            ("mysql", "postgres"): "supported-but-different",
+        },
+    },
+    "LENGTH": {
+        "argument_semantics": "string length; byte-vs-character semantics may differ",
+        "return_shape": "scalar integer-like value",
+        "null_behavior": "NULL input produces NULL",
+        "notes": "MySQL LENGTH is byte-oriented while Oracle LENGTH is character-oriented.",
+        "pairs": {
+            ("mysql", "oracle"): "supported-but-different",
+        },
+    },
+    "CONCAT": {
+        "argument_semantics": "variadic string concatenation",
+        "return_shape": "string",
+        "null_behavior": "NULL propagation semantics differ by dialect",
+        "notes": "MySQL CONCAT propagates NULL arguments; PostgreSQL CONCAT ignores NULL arguments.",
+        "pairs": {
+            ("mysql", "postgres"): "supported-but-different",
+        },
+    },
+    "GET_JSON_OBJECT": {
+        "argument_semantics": "extract a JSON path value with dialect-specific JSON path/operator semantics",
+        "return_shape": "scalar text-like JSON value",
+        "null_behavior": "path/input failures are dialect-sensitive",
+        "notes": "Hive GET_JSON_OBJECT is not a semantic synonym for PostgreSQL JSON operators.",
+        "pairs": {
+            ("hive", "postgres"): "supported-but-different",
+        },
+    },
+    "COLLECT_LIST": {
+        "argument_semantics": "aggregate input values into a collection; ordering is not implied unless explicitly specified",
+        "return_shape": "array/list-like aggregate",
+        "null_behavior": "NULL inclusion/filtering is dialect-sensitive",
+        "notes": "Spark COLLECT_LIST and PostgreSQL ARRAY_AGG differ in output type and ordering guarantees.",
+        "pairs": {
+            ("spark", "postgres"): "supported-but-different",
+        },
+    },
+    "ROW_NUMBER": {
+        "argument_semantics": "assign sequential row numbers within an optional window specification",
+        "return_shape": "integer-like value",
+        "null_behavior": "window ordering determines numbering; NULL ordering remains dialect-sensitive",
+        "notes": "Core window semantics are equivalent for the reviewed pair when the same ORDER BY semantics are preserved.",
+        "pairs": {
+            ("postgres", "mysql"): "equivalent",
+        },
+    },
+    "REGEXP_REPLACE": {
+        "argument_semantics": "replace regex matches using dialect-specific regex engines and replacement rules",
+        "return_shape": "string",
+        "null_behavior": "NULL input produces NULL",
+        "notes": "T-SQL has no native REGEXP_REPLACE equivalent in the reviewed baseline.",
+        "pairs": {},
+    },
+}
+
+
+class FunctionSemanticRegistry:
+    """Resolve explicit semantic equivalence for reviewed SQL functions."""
+
+    def __init__(self, semantics: Dict[str, Dict[str, Any]] = None) -> None:
+        self._semantics = semantics if semantics is not None else _FUNCTION_SEMANTICS
+
+    def resolve(self, function: str, source: str, target: str) -> Dict[str, Any]:
+        """Return an explicit semantic classification for a function pair."""
+        function_name = function.upper().strip()
+        source_dialect = source.lower().strip()
+        target_dialect = target.lower().strip()
+        metadata = self._semantics.get(function_name)
+
+        if metadata is None:
+            return {
+                "function": function_name,
+                "source_dialect": source_dialect,
+                "target_dialect": target_dialect,
+                "status": _SEMANTIC_STATUS["unknown"],
+                "equivalent": False,
+                "reason": "Function is not present in the reviewed semantic registry.",
+            }
+
+        pair_status = metadata.get("pairs", {}).get((source_dialect, target_dialect))
+        if pair_status is None:
+            if function_name == "REGEXP_REPLACE" and target_dialect == "tsql":
+                pair_status = _SEMANTIC_STATUS["unsupported"]
+            else:
+                pair_status = _SEMANTIC_STATUS["unknown"]
+
+        return {
+            "function": function_name,
+            "source_dialect": source_dialect,
+            "target_dialect": target_dialect,
+            "status": pair_status,
+            "equivalent": pair_status == _SEMANTIC_STATUS["equivalent"],
+            "argument_semantics": metadata.get("argument_semantics", ""),
+            "return_shape": metadata.get("return_shape", ""),
+            "null_behavior": metadata.get("null_behavior", ""),
+            "notes": metadata.get("notes", ""),
+        }
+
+    def get_metadata(self, function: str) -> Dict[str, Any]:
+        """Return reviewed metadata without inferring semantic equivalence."""
+        return self._semantics.get(function.upper().strip(), {})