sqlspec 0.17.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

sqlspec/loader.py

@@ -1,17 +1,15 @@
-"""SQL file loader module for managing SQL statements from files.
+"""SQL file loader for managing SQL statements from files.
 
-This module provides functionality to load, cache, and manage SQL statements
+Provides functionality to load, cache, and manage SQL statements
 from files using aiosql-style named queries.
 """
 
 import hashlib
 import re
 import time
-from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from difflib import get_close_matches
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Final, Optional, Union
 
 from sqlspec.core.cache import CacheKey, get_cache_config, get_default_cache
 from sqlspec.core.statement import SQL
@@ -21,11 +19,13 @@ from sqlspec.exceptions import (
     SQLFileParseError,
     StorageOperationFailedError,
 )
-from sqlspec.storage import storage_registry
-from sqlspec.storage.registry import StorageRegistry
+from sqlspec.storage.registry import storage_registry as default_storage_registry
 from sqlspec.utils.correlation import CorrelationContext
 from sqlspec.utils.logging import get_logger
 
+if TYPE_CHECKING:
+    from sqlspec.storage.registry import StorageRegistry
+
 __all__ = ("CachedSQLFile", "NamedStatement", "SQLFile", "SQLFileLoader")
 
 logger = get_logger("loader")
@@ -38,48 +38,8 @@ TRIM_SPECIAL_CHARS = re.compile(r"[^\w.-]")
 # Matches: -- dialect: dialect_name (optional dialect specification)
 DIALECT_PATTERN = re.compile(r"^\s*--\s*dialect\s*:\s*(?P<dialect>[a-zA-Z0-9_]+)\s*$", re.IGNORECASE | re.MULTILINE)
 
-# Supported SQL dialects (based on SQLGlot's available dialects)
-SUPPORTED_DIALECTS = {
-    # Core databases
-    "sqlite",
-    "postgresql",
-    "postgres",
-    "mysql",
-    "oracle",
-    "mssql",
-    "tsql",
-    # Cloud platforms
-    "bigquery",
-    "snowflake",
-    "redshift",
-    "athena",
-    "fabric",
-    # Analytics engines
-    "clickhouse",
-    "duckdb",
-    "databricks",
-    "spark",
-    "spark2",
-    "trino",
-    "presto",
-    # Specialized
-    "hive",
-    "drill",
-    "druid",
-    "materialize",
-    "teradata",
-    "dremio",
-    "doris",
-    "risingwave",
-    "singlestore",
-    "starrocks",
-    "tableau",
-    "exasol",
-    "dune",
-}
 
-# Dialect aliases for common variants
-DIALECT_ALIASES = {
+DIALECT_ALIASES: Final = {
     "postgresql": "postgres",
     "pg": "postgres",
     "pgplsql": "postgres",
@@ -88,7 +48,7 @@ DIALECT_ALIASES = {
     "tsql": "mssql",
 }
 
-MIN_QUERY_PARTS = 3
+MIN_QUERY_PARTS: Final = 3
 
 
 def _normalize_query_name(name: str) -> str:
@@ -129,19 +89,6 @@ def _normalize_dialect_for_sqlglot(dialect: str) -> str:
     return DIALECT_ALIASES.get(normalized, normalized)
 
 
-def _get_dialect_suggestions(invalid_dialect: str) -> "list[str]":
-    """Get dialect suggestions using fuzzy matching.
-
-    Args:
-        invalid_dialect: Invalid dialect name that was provided
-
-    Returns:
-        List of suggested dialect names (up to 3 suggestions)
-    """
-
-    return get_close_matches(invalid_dialect, SUPPORTED_DIALECTS, n=3, cutoff=0.6)
-
-
 class NamedStatement:
     """Represents a parsed SQL statement with metadata.
 
@@ -159,7 +106,6 @@ class NamedStatement:
         self.start_line = start_line
 
 
-@dataclass
 class SQLFile:
     """Represents a loaded SQL file with metadata.
 
@@ -167,28 +113,32 @@ class SQLFile:
     timestamps, and content hash.
     """
 
-    content: str
-    """The raw SQL content from the file."""
+    __slots__ = ("checksum", "content", "loaded_at", "metadata", "path")
 
-    path: str
-    """Path where the SQL file was loaded from."""
+    def __init__(
+        self,
+        content: str,
+        path: str,
+        metadata: "Optional[dict[str, Any]]" = None,
+        loaded_at: "Optional[datetime]" = None,
+    ) -> None:
+        """Initialize SQLFile.
 
-    metadata: "dict[str, Any]" = field(default_factory=dict)
-    """Optional metadata associated with the SQL file."""
-
-    checksum: str = field(init=False)
-    """MD5 checksum of the SQL content for cache invalidation."""
-
-    loaded_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
-    """Timestamp when the file was loaded."""
-
-    def __post_init__(self) -> None:
-        """Calculate checksum after initialization."""
+        Args:
+            content: The raw SQL content from the file.
+            path: Path where the SQL file was loaded from.
+            metadata: Optional metadata associated with the SQL file.
+            loaded_at: Timestamp when the file was loaded.
+        """
+        self.content = content
+        self.path = path
+        self.metadata = metadata or {}
+        self.loaded_at = loaded_at or datetime.now(timezone.utc)
         self.checksum = hashlib.md5(self.content.encode(), usedforsecurity=False).hexdigest()
 
 
 class CachedSQLFile:
-    """Cached SQL file with parsed statements for efficient reloading.
+    """Cached SQL file with parsed statements.
 
     Stored in the file cache to avoid re-parsing SQL files when their
     content hasn't changed.
@@ -205,17 +155,19 @@ class CachedSQLFile:
         """
         self.sql_file = sql_file
         self.parsed_statements = parsed_statements
-        self.statement_names = list(parsed_statements.keys())
+        self.statement_names = tuple(parsed_statements.keys())
 
 
 class SQLFileLoader:
     """Loads and parses SQL files with aiosql-style named queries.
 
-    Provides functionality to load SQL files containing named queries
-    (using -- name: syntax) and retrieve them by name.
+    Loads SQL files containing named queries (using -- name: syntax)
+    and retrieves them by name.
     """
 
-    def __init__(self, *, encoding: str = "utf-8", storage_registry: StorageRegistry = storage_registry) -> None:
+    __slots__ = ("_files", "_queries", "_query_to_file", "encoding", "storage_registry")
+
+    def __init__(self, *, encoding: str = "utf-8", storage_registry: "Optional[StorageRegistry]" = None) -> None:
         """Initialize the SQL file loader.
 
         Args:
@@ -223,7 +175,8 @@ class SQLFileLoader:
             storage_registry: Storage registry for handling file URIs.
         """
         self.encoding = encoding
-        self.storage_registry = storage_registry
+
+        self.storage_registry = storage_registry or default_storage_registry
         self._queries: dict[str, NamedStatement] = {}
         self._files: dict[str, SQLFile] = {}
         self._query_to_file: dict[str, str] = {}
@@ -309,7 +262,6 @@ class SQLFileLoader:
         except KeyError as e:
             raise SQLFileNotFoundError(path_str) from e
         except MissingDependencyError:
-            # Fall back to standard file reading when no storage backend is available
             try:
                 return path.read_text(encoding=self.encoding)  # type: ignore[union-attr]
             except FileNotFoundError as e:
@@ -350,7 +302,6 @@ class SQLFileLoader:
                               or invalid dialect names are specified
         """
         statements: dict[str, NamedStatement] = {}
-        content.splitlines()
 
         name_matches = list(QUERY_NAME_PATTERN.finditer(content))
         if not name_matches:
@@ -379,20 +330,7 @@ class SQLFileLoader:
                 if dialect_match:
                     declared_dialect = dialect_match.group("dialect").lower()
 
-                    normalized_dialect = _normalize_dialect(declared_dialect)
-
-                    if normalized_dialect not in SUPPORTED_DIALECTS:
-                        suggestions = _get_dialect_suggestions(normalized_dialect)
-                        warning_msg = f"Unknown dialect '{declared_dialect}' at line {statement_start_line + 1}"
-                        if suggestions:
-                            warning_msg += f". Did you mean: {', '.join(suggestions)}?"
-                        warning_msg += (
-                            f". Supported dialects: {', '.join(sorted(SUPPORTED_DIALECTS))}. Using dialect as-is."
-                        )
-                        logger.warning(warning_msg)
-                        dialect = declared_dialect.lower()
-                    else:
-                        dialect = normalized_dialect
+                    dialect = _normalize_dialect(declared_dialect)
                     remaining_lines = section_lines[1:]
                     statement_sql = "\n".join(remaining_lines)
 
@@ -473,7 +411,7 @@ class SQLFileLoader:
             raise
 
     def _load_directory(self, dir_path: Path) -> int:
-        """Load all SQL files from a directory with namespacing."""
+        """Load all SQL files from a directory."""
         sql_files = list(dir_path.rglob("*.sql"))
         if not sql_files:
             return 0
@@ -486,7 +424,7 @@ class SQLFileLoader:
         return len(sql_files)
 
     def _load_single_file(self, file_path: Union[str, Path], namespace: Optional[str]) -> None:
-        """Load a single SQL file with optional namespace and caching.
+        """Load a single SQL file with optional namespace.
 
         Args:
             file_path: Path to the SQL file.
@@ -543,7 +481,7 @@ class SQLFileLoader:
             unified_cache.put(cache_key, cached_file_data)
 
     def _load_file_without_cache(self, file_path: Union[str, Path], namespace: Optional[str]) -> None:
-        """Load a single SQL file without caching.
+        """Load a single SQL file without using cache.
 
         Args:
             file_path: Path to the SQL file.
@@ -580,7 +518,7 @@ class SQLFileLoader:
         Raises:
             ValueError: If query name already exists.
         """
-        # Normalize the name for consistency with file-loaded queries
+
         normalized_name = _normalize_query_name(name)
 
         if normalized_name in self._queries:
@@ -589,17 +527,7 @@ class SQLFileLoader:
             raise ValueError(msg)
 
         if dialect is not None:
-            normalized_dialect = _normalize_dialect(dialect)
-            if normalized_dialect not in SUPPORTED_DIALECTS:
-                suggestions = _get_dialect_suggestions(normalized_dialect)
-                warning_msg = f"Unknown dialect '{dialect}'"
-                if suggestions:
-                    warning_msg += f". Did you mean: {', '.join(suggestions)}?"
-                warning_msg += f". Supported dialects: {', '.join(sorted(SUPPORTED_DIALECTS))}. Using dialect as-is."
-                logger.warning(warning_msg)
-                dialect = dialect.lower()
-            else:
-                dialect = normalized_dialect
+            dialect = _normalize_dialect(dialect)
 
         statement = NamedStatement(name=normalized_name, sql=sql.strip(), dialect=dialect, start_line=0)
         self._queries[normalized_name] = statement

sqlspec/migrations/__init__.py

@@ -1,7 +1,7 @@
 """SQLSpec Migration Tool.
 
 A native migration system for SQLSpec that leverages the SQLFileLoader
-and driver architecture for database versioning.
+and driver system for database versioning.
 """
 
 from sqlspec.migrations.commands import AsyncMigrationCommands, MigrationCommands, SyncMigrationCommands

sqlspec/migrations/base.py

@@ -3,18 +3,19 @@
 This module provides abstract base classes for migration components.
 """
 
+import hashlib
 import operator
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, Generic, Optional, TypeVar
+from typing import Any, Generic, Optional, TypeVar, cast
 
 from sqlspec._sql import sql
+from sqlspec.builder import Delete, Insert, Select
 from sqlspec.builder._ddl import CreateTable
-from sqlspec.core.statement import SQL
 from sqlspec.loader import SQLFileLoader
 from sqlspec.migrations.loaders import get_migration_loader
 from sqlspec.utils.logging import get_logger
-from sqlspec.utils.sync_tools import run_
+from sqlspec.utils.sync_tools import await_
 
 __all__ = ("BaseMigrationCommands", "BaseMigrationRunner", "BaseMigrationTracker")
 
@@ -28,6 +29,8 @@ ConfigT = TypeVar("ConfigT")
 class BaseMigrationTracker(ABC, Generic[DriverT]):
     """Base class for migration version tracking."""
 
+    __slots__ = ("version_table",)
+
     def __init__(self, version_table_name: str = "ddl_migrations") -> None:
         """Initialize the migration tracker.
 
@@ -36,54 +39,43 @@ class BaseMigrationTracker(ABC, Generic[DriverT]):
         """
         self.version_table = version_table_name
 
-    def _get_create_table_sql(self) -> SQL:
-        """Get SQL for creating the tracking table.
+    def _get_create_table_sql(self) -> CreateTable:
+        """Get SQL builder for creating the tracking table.
 
         Returns:
-            SQL object for table creation.
+            SQL builder object for table creation.
         """
-        builder = CreateTable(self.version_table)
-        if not hasattr(builder, "_columns"):
-            builder._columns = []
-        if not hasattr(builder, "_constraints"):
-            builder._constraints = []
-        if not hasattr(builder, "_table_options"):
-            builder._table_options = {}
-
         return (
-            builder.if_not_exists()
+            sql.create_table(self.version_table)
+            .if_not_exists()
             .column("version_num", "VARCHAR(32)", primary_key=True)
             .column("description", "TEXT")
-            .column("applied_at", "TIMESTAMP", not_null=True, default="CURRENT_TIMESTAMP")
+            .column("applied_at", "TIMESTAMP", default="CURRENT_TIMESTAMP", not_null=True)
             .column("execution_time_ms", "INTEGER")
             .column("checksum", "VARCHAR(64)")
             .column("applied_by", "VARCHAR(255)")
-        ).to_statement()
+        )
 
-    def _get_current_version_sql(self) -> SQL:
-        """Get SQL for retrieving current version.
+    def _get_current_version_sql(self) -> Select:
+        """Get SQL builder for retrieving current version.
 
         Returns:
-            SQL object for version query.
+            SQL builder object for version query.
         """
+        return sql.select("version_num").from_(self.version_table).order_by("version_num DESC").limit(1)
 
-        return (
-            sql.select("version_num").from_(self.version_table).order_by("version_num DESC").limit(1)
-        ).to_statement()
-
-    def _get_applied_migrations_sql(self) -> SQL:
-        """Get SQL for retrieving all applied migrations.
+    def _get_applied_migrations_sql(self) -> Select:
+        """Get SQL builder for retrieving all applied migrations.
 
         Returns:
-            SQL object for migrations query.
+            SQL builder object for migrations query.
         """
-
-        return (sql.select("*").from_(self.version_table).order_by("version_num")).to_statement()
+        return sql.select("*").from_(self.version_table).order_by("version_num")
 
     def _get_record_migration_sql(
         self, version: str, description: str, execution_time_ms: int, checksum: str, applied_by: str
-    ) -> SQL:
-        """Get SQL for recording a migration.
+    ) -> Insert:
+        """Get SQL builder for recording a migration.
 
         Args:
             version: Version number of the migration.
@@ -93,26 +85,24 @@ class BaseMigrationTracker(ABC, Generic[DriverT]):
             applied_by: User who applied the migration.
 
         Returns:
-            SQL object for insert.
+            SQL builder object for insert.
         """
-
         return (
             sql.insert(self.version_table)
             .columns("version_num", "description", "execution_time_ms", "checksum", "applied_by")
             .values(version, description, execution_time_ms, checksum, applied_by)
-        ).to_statement()
+        )
 
-    def _get_remove_migration_sql(self, version: str) -> SQL:
-        """Get SQL for removing a migration record.
+    def _get_remove_migration_sql(self, version: str) -> Delete:
+        """Get SQL builder for removing a migration record.
 
         Args:
             version: Version number to remove.
 
         Returns:
-            SQL object for delete.
+            SQL builder object for delete.
         """
-
-        return (sql.delete().from_(self.version_table).where(sql.version_num == version)).to_statement()
+        return sql.delete().from_(self.version_table).where(sql.version_num == version)
 
     @abstractmethod
     def ensure_tracking_table(self, driver: DriverT) -> Any:
@@ -176,7 +166,6 @@ class BaseMigrationRunner(ABC, Generic[DriverT]):
         Returns:
             MD5 checksum hex string.
         """
-        import hashlib
 
         return hashlib.md5(content.encode()).hexdigest()  # noqa: S324
 
@@ -226,7 +215,7 @@ class BaseMigrationRunner(ABC, Generic[DriverT]):
             has_upgrade, has_downgrade = self.loader.has_query(up_query), self.loader.has_query(down_query)
         else:
             try:
-                has_downgrade = bool(run_(loader.get_down_sql)(file_path))
+                has_downgrade = bool(await_(loader.get_down_sql, raise_sync_error=False)(file_path))
             except Exception:
                 has_downgrade = False
 
@@ -240,7 +229,7 @@ class BaseMigrationRunner(ABC, Generic[DriverT]):
             "loader": loader,
         }
 
-    def _get_migration_sql(self, migration: "dict[str, Any]", direction: str) -> Optional[SQL]:
+    def _get_migration_sql(self, migration: "dict[str, Any]", direction: str) -> "Optional[list[str]]":
         """Get migration SQL for given direction.
 
         Args:
@@ -261,7 +250,7 @@ class BaseMigrationRunner(ABC, Generic[DriverT]):
 
         try:
             method = loader.get_up_sql if direction == "up" else loader.get_down_sql
-            sql_statements = run_(method)(file_path)
+            sql_statements = await_(method, raise_sync_error=False)(file_path)
 
         except Exception as e:
             if direction == "down":
@@ -271,7 +260,7 @@ class BaseMigrationRunner(ABC, Generic[DriverT]):
             raise ValueError(msg) from e
         else:
             if sql_statements:
-                return SQL(sql_statements[0])
+                return cast("list[str]", sql_statements)
             return None
 
     @abstractmethod
@@ -312,7 +301,7 @@ class BaseMigrationCommands(ABC, Generic[ConfigT, DriverT]):
         self.config = config
         migration_config = getattr(self.config, "migration_config", {}) or {}
 
-        self.version_table = migration_config.get("version_table_name", "sqlspec_migrations")
+        self.version_table = migration_config.get("version_table_name", "ddl_migrations")
         self.migrations_path = Path(migration_config.get("script_location", "migrations"))
         self.project_root = Path(migration_config["project_root"]) if "project_root" in migration_config else None
 

sqlspec/migrations/commands.py

@@ -3,7 +3,7 @@
 This module provides the main command interface for database migrations.
 """
 
-from typing import TYPE_CHECKING, Any, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 from rich.console import Console
 from rich.table import Table
@@ -11,7 +11,6 @@ from rich.table import Table
 from sqlspec._sql import sql
 from sqlspec.migrations.base import BaseMigrationCommands
 from sqlspec.migrations.runner import AsyncMigrationRunner, SyncMigrationRunner
-from sqlspec.migrations.tracker import AsyncMigrationTracker, SyncMigrationTracker
 from sqlspec.migrations.utils import create_migration_file
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.sync_tools import await_
@@ -26,7 +25,7 @@ console = Console()
 
 
 class SyncMigrationCommands(BaseMigrationCommands["SyncConfigT", Any]):
-    """SQLSpec native migration commands."""
+    """Synchronous migration commands."""
 
     def __init__(self, config: "SyncConfigT") -> None:
         """Initialize migration commands.
@@ -35,7 +34,7 @@ class SyncMigrationCommands(BaseMigrationCommands["SyncConfigT", Any]):
             config: The SQLSpec configuration.
         """
         super().__init__(config)
-        self.tracker = SyncMigrationTracker(self.version_table)
+        self.tracker = config.migration_tracker_type(self.version_table)
         self.runner = SyncMigrationRunner(self.migrations_path)
 
     def init(self, directory: str, package: bool = True) -> None:
@@ -47,11 +46,14 @@ class SyncMigrationCommands(BaseMigrationCommands["SyncConfigT", Any]):
         """
         self.init_directory(directory, package)
 
-    def current(self, verbose: bool = False) -> None:
+    def current(self, verbose: bool = False) -> "Optional[str]":
         """Show current migration version.
 
         Args:
             verbose: Whether to show detailed migration history.
+
+        Returns:
+            The current migration version or None if no migrations applied.
         """
         with self.config.provide_session() as driver:
             self.tracker.ensure_tracking_table(driver)
@@ -59,7 +61,7 @@ class SyncMigrationCommands(BaseMigrationCommands["SyncConfigT", Any]):
             current = self.tracker.get_current_version(driver)
             if not current:
                 console.print("[yellow]No migrations applied yet[/]")
-                return
+                return None
 
             console.print(f"[green]Current version:[/] {current}")
 
@@ -84,6 +86,8 @@ class SyncMigrationCommands(BaseMigrationCommands["SyncConfigT", Any]):
 
                 console.print(table)
 
+            return cast("Optional[str]", current)
+
     def upgrade(self, revision: str = "head") -> None:
         """Upgrade to a target revision.
 
@@ -137,6 +141,8 @@ class SyncMigrationCommands(BaseMigrationCommands["SyncConfigT", Any]):
             to_revert = []
             if revision == "-1":
                 to_revert = [applied[-1]]
+            elif revision == "base":
+                to_revert = list(reversed(applied))
             else:
                 for migration in reversed(applied):
                     if migration["version_num"] > revision:
@@ -195,7 +201,7 @@ class SyncMigrationCommands(BaseMigrationCommands["SyncConfigT", Any]):
 
 
 class AsyncMigrationCommands(BaseMigrationCommands["AsyncConfigT", Any]):
-    """SQLSpec native migration commands."""
+    """Asynchronous migration commands."""
 
     def __init__(self, sqlspec_config: "AsyncConfigT") -> None:
         """Initialize migration commands.
@@ -204,7 +210,7 @@ class AsyncMigrationCommands(BaseMigrationCommands["AsyncConfigT", Any]):
             sqlspec_config: The SQLSpec configuration.
         """
         super().__init__(sqlspec_config)
-        self.tracker = AsyncMigrationTracker(self.version_table)
+        self.tracker = sqlspec_config.migration_tracker_type(self.version_table)
         self.runner = AsyncMigrationRunner(self.migrations_path)
 
     async def init(self, directory: str, package: bool = True) -> None:
@@ -216,11 +222,14 @@ class AsyncMigrationCommands(BaseMigrationCommands["AsyncConfigT", Any]):
         """
         self.init_directory(directory, package)
 
-    async def current(self, verbose: bool = False) -> None:
+    async def current(self, verbose: bool = False) -> "Optional[str]":
         """Show current migration version.
 
         Args:
             verbose: Whether to show detailed migration history.
+
+        Returns:
+            The current migration version or None if no migrations applied.
         """
         async with self.config.provide_session() as driver:
             await self.tracker.ensure_tracking_table(driver)
@@ -228,7 +237,7 @@ class AsyncMigrationCommands(BaseMigrationCommands["AsyncConfigT", Any]):
             current = await self.tracker.get_current_version(driver)
             if not current:
                 console.print("[yellow]No migrations applied yet[/]")
-                return
+                return None
 
             console.print(f"[green]Current version:[/] {current}")
             if verbose:
@@ -249,6 +258,8 @@ class AsyncMigrationCommands(BaseMigrationCommands["AsyncConfigT", Any]):
                     )
                 console.print(table)
 
+            return cast("Optional[str]", current)
+
     async def upgrade(self, revision: str = "head") -> None:
         """Upgrade to a target revision.
 
@@ -297,6 +308,8 @@ class AsyncMigrationCommands(BaseMigrationCommands["AsyncConfigT", Any]):
             to_revert = []
             if revision == "-1":
                 to_revert = [applied[-1]]
+            elif revision == "base":
+                to_revert = list(reversed(applied))
             else:
                 for migration in reversed(applied):
                     if migration["version_num"] > revision:
@@ -382,20 +395,26 @@ class MigrationCommands:
             package: Whether to create __init__.py file.
         """
         if self._is_async:
-            await_(cast("AsyncMigrationCommands[Any]", self._impl).init)(directory, package=package)
+            await_(cast("AsyncMigrationCommands[Any]", self._impl).init, raise_sync_error=False)(
+                directory, package=package
+            )
         else:
             cast("SyncMigrationCommands[Any]", self._impl).init(directory, package=package)
 
-    def current(self, verbose: bool = False) -> None:
+    def current(self, verbose: bool = False) -> "Optional[str]":
         """Show current migration version.
 
         Args:
             verbose: Whether to show detailed migration history.
+
+        Returns:
+            The current migration version or None if no migrations applied.
         """
         if self._is_async:
-            await_(cast("AsyncMigrationCommands[Any]", self._impl).current, raise_sync_error=False)(verbose=verbose)
-        else:
-            cast("SyncMigrationCommands[Any]", self._impl).current(verbose=verbose)
+            return await_(cast("AsyncMigrationCommands[Any]", self._impl).current, raise_sync_error=False)(
+                verbose=verbose
+            )
+        return cast("SyncMigrationCommands[Any]", self._impl).current(verbose=verbose)
 
     def upgrade(self, revision: str = "head") -> None:
         """Upgrade to a target revision.

sqlspec/migrations/loaders.py

@@ -70,7 +70,7 @@ class BaseMigrationLoader(abc.ABC):
 
 
 class SQLFileLoader(BaseMigrationLoader):
-    """Loader for SQL migration files using SQLFileLoader."""
+    """Loader for SQL migration files."""
 
     __slots__ = ("sql_loader",)