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

sqlspec/driver/mixins/_storage.py

@@ -85,25 +85,30 @@ class StorageMixinBase(ABC):
             raise MissingDependencyError(msg)
 
     @staticmethod
-    def _get_storage_backend(uri_or_key: str) -> "ObjectStoreProtocol":
+    def _get_storage_backend(uri_or_key: "Union[str, Path]") -> "ObjectStoreProtocol":
         """Get storage backend by URI or key with intelligent routing."""
-        return storage_registry.get(uri_or_key)
+        # Pass Path objects directly to storage registry for proper URI conversion
+        if isinstance(uri_or_key, Path):
+            return storage_registry.get(uri_or_key)
+        return storage_registry.get(str(uri_or_key))
 
     @staticmethod
-    def _is_uri(path_or_uri: str) -> bool:
+    def _is_uri(path_or_uri: "Union[str, Path]") -> bool:
         """Check if input is a URI rather than a relative path."""
+        path_str = str(path_or_uri)
         schemes = {"s3", "gs", "gcs", "az", "azure", "abfs", "abfss", "file", "http", "https"}
-        if "://" in path_or_uri:
-            scheme = path_or_uri.split("://", maxsplit=1)[0].lower()
+        if "://" in path_str:
+            scheme = path_str.split("://", maxsplit=1)[0].lower()
             return scheme in schemes
-        if len(path_or_uri) >= WINDOWS_PATH_MIN_LENGTH and path_or_uri[1:3] == ":\\":
+        if len(path_str) >= WINDOWS_PATH_MIN_LENGTH and path_str[1:3] == ":\\":
             return True
-        return bool(path_or_uri.startswith("/"))
+        return bool(path_str.startswith("/"))
 
     @staticmethod
-    def _detect_format(uri: str) -> str:
+    def _detect_format(uri: "Union[str, Path]") -> str:
         """Detect file format from URI extension."""
-        parsed = urlparse(uri)
+        uri_str = str(uri)
+        parsed = urlparse(uri_str)
         path = Path(parsed.path)
         extension = path.suffix.lower().lstrip(".")
 
@@ -120,28 +125,28 @@ class StorageMixinBase(ABC):
 
         return format_map.get(extension, "csv")
 
-    def _resolve_backend_and_path(self, uri: str) -> "tuple[ObjectStoreProtocol, str]":
+    def _resolve_backend_and_path(self, uri: "Union[str, Path]") -> "tuple[ObjectStoreProtocol, str]":
         """Resolve backend and path from URI with Phase 3 URI-first routing.
 
         Args:
-            uri: URI to resolve (e.g., "s3://bucket/path", "file:///local/path")
+            uri: URI to resolve (e.g., "s3://bucket/path", "file:///local/path", Path object)
 
         Returns:
             Tuple of (backend, path) where path is relative to the backend's base path
         """
         # Convert Path objects to string
-        uri = str(uri)
-        original_path = uri
+        uri_str = str(uri)
+        original_path = uri_str
 
         # Convert absolute paths to file:// URIs if needed
-        if self._is_uri(uri) and "://" not in uri:
+        if self._is_uri(uri_str) and "://" not in uri_str:
             # It's an absolute path without scheme
-            uri = f"file://{uri}"
+            uri_str = f"file://{uri_str}"
 
-        backend = self._get_storage_backend(uri)
+        backend = self._get_storage_backend(uri_str)
 
         # For file:// URIs, return just the path part for the backend
-        path = uri[7:] if uri.startswith("file://") else original_path
+        path = uri_str[7:] if uri_str.startswith("file://") else original_path
 
         return backend, path
 
@@ -293,7 +298,7 @@ class SyncStorageMixin(StorageMixinBase):
         statement: "Statement",
         /,
         *parameters: "Union[StatementParameters, StatementFilter]",
-        destination_uri: str,
+        destination_uri: "Union[str, Path]",
         format: "Optional[str]" = None,
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
@@ -340,7 +345,7 @@ class SyncStorageMixin(StorageMixinBase):
         statement: "Statement",
         /,
         *parameters: "Union[StatementParameters, StatementFilter]",
-        destination_uri: str,
+        destination_uri: "Union[str, Path]",
         format: "Optional[str]" = None,
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
@@ -360,7 +365,7 @@ class SyncStorageMixin(StorageMixinBase):
         detected_format = self._detect_format(destination_uri)
         if format:
             file_format = format
-        elif detected_format == "csv" and not destination_uri.endswith((".csv", ".tsv", ".txt")):
+        elif detected_format == "csv" and not str(destination_uri).endswith((".csv", ".tsv", ".txt")):
             # Detection returned default "csv" but file doesn't actually have CSV extension
             # Default to parquet for better compatibility with tests and common usage
             file_format = "parquet"
@@ -370,7 +375,7 @@ class SyncStorageMixin(StorageMixinBase):
         # Special handling for parquet format - if we're exporting to parquet but the
         # destination doesn't have .parquet extension, add it to ensure compatibility
         # with pyarrow.parquet.read_table() which requires the extension
-        if file_format == "parquet" and not destination_uri.endswith(".parquet"):
+        if file_format == "parquet" and not str(destination_uri).endswith(".parquet"):
             destination_uri = f"{destination_uri}.parquet"
 
         # Use storage backend - resolve AFTER modifying destination_uri
@@ -412,7 +417,12 @@ class SyncStorageMixin(StorageMixinBase):
         return self._export_via_backend(sql_obj, backend, path, file_format, **kwargs)
 
     def import_from_storage(
-        self, source_uri: str, table_name: str, format: "Optional[str]" = None, mode: str = "create", **options: Any
+        self,
+        source_uri: "Union[str, Path]",
+        table_name: str,
+        format: "Optional[str]" = None,
+        mode: str = "create",
+        **options: Any,
     ) -> int:
         """Import data from storage with intelligent routing.
 
@@ -431,7 +441,12 @@ class SyncStorageMixin(StorageMixinBase):
         return self._import_from_storage(source_uri, table_name, format, mode, **options)
 
     def _import_from_storage(
-        self, source_uri: str, table_name: str, format: "Optional[str]" = None, mode: str = "create", **options: Any
+        self,
+        source_uri: "Union[str, Path]",
+        table_name: str,
+        format: "Optional[str]" = None,
+        mode: str = "create",
+        **options: Any,
     ) -> int:
         """Protected method for import operation implementation.
 
@@ -461,7 +476,23 @@ class SyncStorageMixin(StorageMixinBase):
                 arrow_table = backend.read_arrow(path, **options)
                 return self.ingest_arrow_table(arrow_table, table_name, mode=mode)
             except AttributeError:
-                pass
+                # Backend doesn't support read_arrow, try alternative approach
+                try:
+                    import pyarrow.parquet as pq
+
+                    # Read Parquet file directly
+                    with tempfile.NamedTemporaryFile(mode="wb", suffix=".parquet", delete=False) as tmp:
+                        tmp.write(backend.read_bytes(path))
+                        tmp_path = Path(tmp.name)
+                    try:
+                        arrow_table = pq.read_table(tmp_path)
+                        return self.ingest_arrow_table(arrow_table, table_name, mode=mode)
+                    finally:
+                        tmp_path.unlink(missing_ok=True)
+                except ImportError:
+                    # PyArrow not installed, cannot import Parquet
+                    msg = "PyArrow is required to import Parquet files. Install with: pip install pyarrow"
+                    raise ImportError(msg) from None
 
         # Use traditional import through temporary file
         return self._import_via_backend(backend, path, table_name, file_format, mode, **options)
@@ -471,23 +502,27 @@ class SyncStorageMixin(StorageMixinBase):
     # ============================================================================
 
     def _read_parquet_native(
-        self, source_uri: str, columns: "Optional[list[str]]" = None, **options: Any
+        self, source_uri: "Union[str, Path]", columns: "Optional[list[str]]" = None, **options: Any
     ) -> "SQLResult":
         """Database-specific native Parquet reading. Override in drivers."""
         msg = "Driver should implement _read_parquet_native"
         raise NotImplementedError(msg)
 
-    def _write_parquet_native(self, data: Union[str, ArrowTable], destination_uri: str, **options: Any) -> None:
+    def _write_parquet_native(
+        self, data: Union[str, ArrowTable], destination_uri: "Union[str, Path]", **options: Any
+    ) -> None:
         """Database-specific native Parquet writing. Override in drivers."""
         msg = "Driver should implement _write_parquet_native"
         raise NotImplementedError(msg)
 
-    def _export_native(self, query: str, destination_uri: str, format: str, **options: Any) -> int:
+    def _export_native(self, query: str, destination_uri: "Union[str, Path]", format: str, **options: Any) -> int:
         """Database-specific native export. Override in drivers."""
         msg = "Driver should implement _export_native"
         raise NotImplementedError(msg)
 
-    def _import_native(self, source_uri: str, table_name: str, format: str, mode: str, **options: Any) -> int:
+    def _import_native(
+        self, source_uri: "Union[str, Path]", table_name: str, format: str, mode: str, **options: Any
+    ) -> int:
         """Database-specific native import. Override in drivers."""
         msg = "Driver should implement _import_native"
         raise NotImplementedError(msg)
@@ -743,7 +778,7 @@ class AsyncStorageMixin(StorageMixinBase):
         statement: "Statement",
         /,
         *parameters: "Union[StatementParameters, StatementFilter]",
-        destination_uri: str,
+        destination_uri: "Union[str, Path]",
         format: "Optional[str]" = None,
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
@@ -770,7 +805,7 @@ class AsyncStorageMixin(StorageMixinBase):
     async def _export_to_storage(
         self,
         query: "SQL",
-        destination_uri: str,
+        destination_uri: "Union[str, Path]",
         format: "Optional[str]" = None,
         connection: "Optional[ConnectionT]" = None,
         **options: Any,
@@ -793,7 +828,7 @@ class AsyncStorageMixin(StorageMixinBase):
         detected_format = self._detect_format(destination_uri)
         if format:
             file_format = format
-        elif detected_format == "csv" and not destination_uri.endswith((".csv", ".tsv", ".txt")):
+        elif detected_format == "csv" and not str(destination_uri).endswith((".csv", ".tsv", ".txt")):
             # Detection returned default "csv" but file doesn't actually have CSV extension
             # Default to parquet for better compatibility with tests and common usage
             file_format = "parquet"
@@ -803,7 +838,7 @@ class AsyncStorageMixin(StorageMixinBase):
         # Special handling for parquet format - if we're exporting to parquet but the
         # destination doesn't have .parquet extension, add it to ensure compatibility
         # with pyarrow.parquet.read_table() which requires the extension
-        if file_format == "parquet" and not destination_uri.endswith(".parquet"):
+        if file_format == "parquet" and not str(destination_uri).endswith(".parquet"):
             destination_uri = f"{destination_uri}.parquet"
 
         # Use storage backend - resolve AFTER modifying destination_uri
@@ -838,7 +873,12 @@ class AsyncStorageMixin(StorageMixinBase):
         return await self._export_via_backend(query, backend, path, file_format, **options)
 
     async def import_from_storage(
-        self, source_uri: str, table_name: str, format: "Optional[str]" = None, mode: str = "create", **options: Any
+        self,
+        source_uri: "Union[str, Path]",
+        table_name: str,
+        format: "Optional[str]" = None,
+        mode: str = "create",
+        **options: Any,
     ) -> int:
         """Async import data from storage with intelligent routing.
 
@@ -857,7 +897,12 @@ class AsyncStorageMixin(StorageMixinBase):
         return await self._import_from_storage(source_uri, table_name, format, mode, **options)
 
     async def _import_from_storage(
-        self, source_uri: str, table_name: str, format: "Optional[str]" = None, mode: str = "create", **options: Any
+        self,
+        source_uri: "Union[str, Path]",
+        table_name: str,
+        format: "Optional[str]" = None,
+        mode: str = "create",
+        **options: Any,
     ) -> int:
         """Protected async method for import operation implementation.
 
@@ -884,12 +929,14 @@ class AsyncStorageMixin(StorageMixinBase):
     # Async Database-Specific Implementation Hooks
     # ============================================================================
 
-    async def _export_native(self, query: str, destination_uri: str, format: str, **options: Any) -> int:
+    async def _export_native(self, query: str, destination_uri: "Union[str, Path]", format: str, **options: Any) -> int:
         """Async database-specific native export."""
         msg = "Driver should implement _export_native"
         raise NotImplementedError(msg)
 
-    async def _import_native(self, source_uri: str, table_name: str, format: str, mode: str, **options: Any) -> int:
+    async def _import_native(
+        self, source_uri: "Union[str, Path]", table_name: str, format: str, mode: str, **options: Any
+    ) -> int:
         """Async database-specific native import."""
         msg = "Driver should implement _import_native"
         raise NotImplementedError(msg)

sqlspec/loader.py

@@ -113,7 +113,7 @@ class SQLFileLoader:
         self._query_to_file: dict[str, str] = {}  # Maps query name to file path
 
     def _read_file_content(self, path: Union[str, Path]) -> str:
-        """Read file content using appropriate backend.
+        """Read file content using storage backend.
 
         Args:
             path: File path (can be local path or URI).
@@ -126,37 +126,15 @@ class SQLFileLoader:
         """
         path_str = str(path)
 
-        # Use storage backend for URIs (anything with a scheme)
-        if "://" in path_str:
-            try:
-                backend = self.storage_registry.get(path_str)
-                return backend.read_text(path_str, encoding=self.encoding)
-            except KeyError as e:
-                raise SQLFileNotFoundError(path_str) from e
-            except Exception as e:
-                raise SQLFileParseError(path_str, path_str, e) from e
-
-        # Handle local file paths
-        local_path = Path(path_str)
-        self._check_file_path(local_path)
-        content_bytes = self._read_file_content_bytes(local_path)
-        return content_bytes.decode(self.encoding)
-
-    @staticmethod
-    def _read_file_content_bytes(path: Path) -> bytes:
         try:
-            return path.read_bytes()
+            # Always use storage backend for consistent behavior
+            # Pass the original path object to allow storage registry to handle Path -> file:// conversion
+            backend = self.storage_registry.get(path)
+            return backend.read_text(path_str, encoding=self.encoding)
+        except KeyError as e:
+            raise SQLFileNotFoundError(path_str) from e
         except Exception as e:
-            raise SQLFileParseError(str(path), str(path), e) from e
-
-    @staticmethod
-    def _check_file_path(path: Union[str, Path]) -> None:
-        """Ensure the file exists and is a valid path."""
-        path_obj = Path(path).resolve()
-        if not path_obj.exists():
-            raise SQLFileNotFoundError(str(path_obj))
-        if not path_obj.is_file():
-            raise SQLFileParseError(str(path_obj), str(path_obj), ValueError("Path is not a file"))
+            raise SQLFileParseError(path_str, path_str, e) from e
 
     @staticmethod
     def _strip_leading_comments(sql_text: str) -> str:

sqlspec/statement/builder/base.py

@@ -192,7 +192,9 @@ class QueryBuilder(ABC, Generic[RowT]):
                 self._raise_sql_builder_error(msg)
             cte_select_expression = query._expression.copy()
             for p_name, p_value in query._parameters.items():
-                self.add_parameter(p_value, f"cte_{alias}_{p_name}")
+                # Try to preserve original parameter name, only rename if collision
+                unique_name = self._generate_unique_parameter_name(p_name)
+                self.add_parameter(p_value, unique_name)
 
         elif isinstance(query, str):
             try:

sqlspec/statement/builder/ddl.py

@@ -769,14 +769,27 @@ class CreateTableAsSelectBuilder(DDLBuilder):
             select_expr = self._select_query.expression
             select_params = getattr(self._select_query, "parameters", None)
         elif isinstance(self._select_query, SelectBuilder):
+            # Get the expression and parameters directly
             select_expr = getattr(self._select_query, "_expression", None)
             select_params = getattr(self._select_query, "_parameters", None)
+
+            # Apply CTEs if present
+            with_ctes = getattr(self._select_query, "_with_ctes", {})
+            if with_ctes and select_expr and isinstance(select_expr, exp.Select):
+                # Apply CTEs directly to the SELECT expression using sqlglot's with_ method
+                for alias, cte in with_ctes.items():
+                    if hasattr(select_expr, "with_"):
+                        select_expr = select_expr.with_(
+                            cte.this,  # The CTE's SELECT expression
+                            as_=alias,
+                            copy=False,
+                        )
         elif isinstance(self._select_query, str):
             select_expr = exp.maybe_parse(self._select_query)
             select_params = None
         else:
             self._raise_sql_builder_error("Unsupported type for SELECT query in CTAS.")
-        if select_expr is None or not isinstance(select_expr, exp.Select):
+        if select_expr is None:
             self._raise_sql_builder_error("SELECT query must be a valid SELECT expression.")
 
         # Merge parameters from SELECT if present

sqlspec/statement/pipelines/analyzers/_analyzer.py

@@ -324,11 +324,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

sqlspec/statement/pipelines/transformers/_literal_parameterizer.py

@@ -34,7 +34,9 @@ class ParameterizationContext:
     in_case_when: bool = False
     in_array: bool = False
     in_in_clause: bool = False
+    in_recursive_cte: bool = False
     function_depth: int = 0
+    cte_depth: int = 0
 
 
 class ParameterizeLiterals(ProcessorProtocol):
@@ -53,6 +55,7 @@ class ParameterizeLiterals(ProcessorProtocol):
         preserve_boolean: Whether to preserve boolean literals as-is.
         preserve_numbers_in_limit: Whether to preserve numbers in LIMIT/OFFSET clauses.
         preserve_in_functions: List of function names where literals should be preserved.
+        preserve_in_recursive_cte: Whether to preserve literals in recursive CTEs (default True to avoid type inference issues).
         parameterize_arrays: Whether to parameterize array literals.
         parameterize_in_lists: Whether to parameterize IN clause lists.
         max_string_length: Maximum string length to parameterize.
@@ -68,6 +71,7 @@ class ParameterizeLiterals(ProcessorProtocol):
         preserve_boolean: bool = True,
         preserve_numbers_in_limit: bool = True,
         preserve_in_functions: Optional[list[str]] = None,
+        preserve_in_recursive_cte: bool = True,
         parameterize_arrays: bool = True,
         parameterize_in_lists: bool = True,
         max_string_length: int = DEFAULT_MAX_STRING_LENGTH,
@@ -79,7 +83,18 @@ class ParameterizeLiterals(ProcessorProtocol):
         self.preserve_null = preserve_null
         self.preserve_boolean = preserve_boolean
         self.preserve_numbers_in_limit = preserve_numbers_in_limit
-        self.preserve_in_functions = preserve_in_functions or ["COALESCE", "IFNULL", "NVL", "ISNULL"]
+        self.preserve_in_recursive_cte = preserve_in_recursive_cte
+        self.preserve_in_functions = preserve_in_functions or [
+            "COALESCE",
+            "IFNULL",
+            "NVL",
+            "ISNULL",
+            # Array functions that take dimension arguments
+            "ARRAYSIZE",  # SQLglot converts array_length to ArraySize
+            "ARRAY_UPPER",
+            "ARRAY_LOWER",
+            "ARRAY_NDIMS",
+        ]
         self.parameterize_arrays = parameterize_arrays
         self.parameterize_in_lists = parameterize_in_lists
         self.max_string_length = max_string_length
@@ -162,6 +177,17 @@ class ParameterizeLiterals(ProcessorProtocol):
                 context.in_array = True
             elif isinstance(node, exp.In):
                 context.in_in_clause = True
+            elif isinstance(node, exp.CTE):
+                context.cte_depth += 1
+                # Check if this CTE is recursive:
+                # 1. Parent WITH must be RECURSIVE
+                # 2. CTE must contain UNION (characteristic of recursive CTEs)
+                is_in_recursive_with = any(
+                    isinstance(parent, exp.With) and parent.args.get("recursive", False)
+                    for parent in reversed(context.parent_stack)
+                )
+                if is_in_recursive_with and self._contains_union(node):
+                    context.in_recursive_cte = True
         else:
             if context.parent_stack:
                 context.parent_stack.pop()
@@ -176,6 +202,10 @@ class ParameterizeLiterals(ProcessorProtocol):
                 context.in_array = False
             elif isinstance(node, exp.In):
                 context.in_in_clause = False
+            elif isinstance(node, exp.CTE):
+                context.cte_depth -= 1
+                if context.cte_depth == 0:
+                    context.in_recursive_cte = False
 
     def _process_literal_with_context(
         self, literal: exp.Expression, context: ParameterizationContext
@@ -206,7 +236,6 @@ class ParameterizeLiterals(ProcessorProtocol):
                 "type": type_hint,
                 "semantic_name": semantic_name,
                 "context": self._get_context_description(context),
-                # Note: We avoid calling literal.sql() for performance
             }
         )
 
@@ -227,6 +256,21 @@ class ParameterizeLiterals(ProcessorProtocol):
         if context.in_function_args:
             return True
 
+        # Preserve literals in recursive CTEs to avoid type inference issues
+        if self.preserve_in_recursive_cte and context.in_recursive_cte:
+            return True
+
+        # Check if this literal is being used as an alias value in SELECT
+        # e.g., 'computed' as process_status should be preserved
+        if hasattr(literal, "parent") and literal.parent:
+            parent = literal.parent
+            # Check if it's an Alias node and the literal is the expression (not the alias name)
+            if isinstance(parent, exp.Alias) and parent.this == literal:
+                # Check if this alias is in a SELECT clause
+                for ancestor in context.parent_stack:
+                    if isinstance(ancestor, exp.Select):
+                        return True
+
         # Check parent context more intelligently
         for parent in context.parent_stack:
             # Preserve in schema/DDL contexts
@@ -616,6 +660,16 @@ class ParameterizeLiterals(ProcessorProtocol):
         """
         return self._parameter_metadata.copy()
 
+    def _contains_union(self, cte_node: exp.CTE) -> bool:
+        """Check if a CTE contains a UNION (characteristic of recursive CTEs)."""
+
+        def has_union(node: exp.Expression) -> bool:
+            if isinstance(node, exp.Union):
+                return True
+            return any(has_union(child) for child in node.iter_expressions())
+
+        return cte_node.this and has_union(cte_node.this)
+
     def clear_parameters(self) -> None:
         """Clear the extracted parameters list."""
         self.extracted_parameters = []

sqlspec/statement/sql.py

@@ -191,7 +191,7 @@ class SQL:
         if _existing_state:
             self._load_from_existing_state(_existing_state)
 
-        if not isinstance(statement, SQL):
+        if not isinstance(statement, SQL) and not _existing_state:
             self._set_original_parameters(*parameters)
 
         self._process_parameters(*parameters, **kwargs)
@@ -235,6 +235,7 @@ class SQL:
         self._is_many = existing_state.get("is_many", self._is_many)
         self._is_script = existing_state.get("is_script", self._is_script)
         self._raw_sql = existing_state.get("raw_sql", self._raw_sql)
+        self._original_parameters = existing_state.get("original_parameters", self._original_parameters)
 
     def _set_original_parameters(self, *parameters: Any) -> None:
         """Store the original parameters for compatibility."""
@@ -493,6 +494,8 @@ class SQL:
             "is_script": self._is_script,
             "raw_sql": self._raw_sql,
         }
+        # Always include original_parameters in existing_state
+        existing_state["original_parameters"] = self._original_parameters
 
         # Create new instance
         new_statement = statement if statement is not None else self._statement
@@ -595,10 +598,9 @@ class SQL:
         new_obj = self.copy()
         new_obj._is_many = True
         if parameters is not None:
-            # Replace parameters for executemany
             new_obj._positional_params = []
             new_obj._named_params = {}
-            new_obj._positional_params = parameters
+            new_obj._original_parameters = parameters
         return new_obj
 
     def as_script(self) -> "SQL":
@@ -677,6 +679,10 @@ class SQL:
     @property
     def parameters(self) -> Any:
         """Get merged parameters."""
+        # For executemany operations, return the original parameters list
+        if self._is_many and self._original_parameters is not None:
+            return self._original_parameters
+
         self._ensure_processed()
         assert self._processed_state is not None
         return self._processed_state.merged_parameters
@@ -710,6 +716,18 @@ class SQL:
         if self._is_script:
             return self.sql, None
 
+        # For executemany operations with original parameters, handle specially
+        if self._is_many and self._original_parameters is not None:
+            # Get the SQL, but use the original parameters list
+            sql = self.sql  # This will ensure processing if needed
+            params = self._original_parameters
+
+            # Convert placeholder style if requested
+            if placeholder_style:
+                sql, params = self._convert_placeholder_style(sql, params, placeholder_style)
+
+            return sql, params
+
         # If parsing is disabled, return raw SQL without transformation
         if not self._config.enable_parsing and self._raw_sql:
             return self._raw_sql, self._raw_parameters
@@ -737,8 +755,6 @@ class SQL:
         if placeholder_style:
             sql, params = self._convert_placeholder_style(sql, params, placeholder_style)
 
-        # Debug log the final SQL
-        logger.debug("Final compiled SQL: '%s'", sql)
         return sql, params
 
     @staticmethod
@@ -803,6 +819,24 @@ class SQL:
         Returns:
             Tuple of (converted_sql, converted_params)
         """
+        # Handle execute_many case where params is a list of parameter sets
+        if self._is_many and isinstance(params, list) and params and isinstance(params[0], (list, tuple)):
+            # For execute_many, we only need to convert the SQL once
+            # The parameters remain as a list of tuples
+            converter = self._config.parameter_converter
+            param_info = converter.validator.extract_parameters(sql)
+
+            if param_info:
+                from sqlspec.statement.parameters import ParameterStyle
+
+                target_style = (
+                    ParameterStyle(placeholder_style) if isinstance(placeholder_style, str) else placeholder_style
+                )
+                sql = self._replace_placeholders_in_sql(sql, param_info, target_style)
+
+            # Parameters remain as list of tuples for execute_many
+            return sql, params
+
         # Extract parameter info from current SQL
         converter = self._config.parameter_converter
         param_info = converter.validator.extract_parameters(sql)
@@ -969,7 +1003,7 @@ class SQL:
                 result_dict["1"] = params
             return result_dict
 
-        if isinstance(params, dict):
+        if is_dict(params):
             # Check if already in correct format (keys are "1", "2", etc.)
             if all(key.isdigit() for key in params):
                 return params