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

sqlspec/adapters/psycopg/driver.py

@@ -13,15 +13,17 @@ from sqlglot.dialects.dialect import DialectType
 from sqlspec.driver import AsyncDriverAdapterProtocol, SyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_async, managed_transaction_sync
 from sqlspec.driver.mixins import (
+    AsyncAdapterCacheMixin,
     AsyncPipelinedExecutionMixin,
     AsyncStorageMixin,
     SQLTranslatorMixin,
+    SyncAdapterCacheMixin,
     SyncPipelinedExecutionMixin,
     SyncStorageMixin,
     ToSchemaMixin,
     TypeCoercionMixin,
 )
-from sqlspec.driver.parameters import normalize_parameter_sequence
+from sqlspec.driver.parameters import convert_parameter_sequence
 from sqlspec.exceptions import PipelineExecutionError
 from sqlspec.statement.parameters import ParameterStyle, ParameterValidator
 from sqlspec.statement.result import ArrowResult, SQLResult
@@ -43,6 +45,7 @@ PsycopgAsyncConnection = AsyncConnection[PsycopgDictRow]
 
 class PsycopgSyncDriver(
     SyncDriverAdapterProtocol[PsycopgSyncConnection, RowT],
+    SyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     SyncStorageMixin,
@@ -57,7 +60,6 @@ class PsycopgSyncDriver(
         ParameterStyle.NAMED_PYFORMAT,
     )
     default_parameter_style: ParameterStyle = ParameterStyle.POSITIONAL_PYFORMAT
-    __slots__ = ()
 
     def __init__(
         self,
@@ -77,7 +79,7 @@ class PsycopgSyncDriver(
         self, statement: SQL, connection: Optional[PsycopgSyncConnection] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return self._execute_script(sql, connection=connection, **kwargs)
 
         detected_styles = set()
@@ -105,7 +107,7 @@ class PsycopgSyncDriver(
                 sql = statement.to_sql(placeholder_style=target_style)
                 params = kwargs_params
             else:
-                sql, params = statement.compile(placeholder_style=target_style)
+                sql, params = self._get_compiled_sql(statement, target_style)
             if params is not None:
                 processed_params = [self._process_parameters(param_set) for param_set in params]
                 params = processed_params
@@ -120,7 +122,7 @@ class PsycopgSyncDriver(
             sql = statement.to_sql(placeholder_style=target_style)
             params = kwargs_params
         else:
-            sql, params = statement.compile(placeholder_style=target_style)
+            sql, params = self._get_compiled_sql(statement, target_style)
         params = self._process_parameters(params)
 
         # Fix over-nested parameters for Psycopg
@@ -231,8 +233,8 @@ class PsycopgSyncDriver(
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
             # Normalize parameter list using consolidated utility
-            normalized_param_list = normalize_parameter_sequence(param_list)
-            final_param_list = normalized_param_list or []
+            converted_param_list = convert_parameter_sequence(param_list)
+            final_param_list = converted_param_list or []
 
             with self._get_cursor(txn_conn) as cursor:
                 cursor.executemany(sql, final_param_list)
@@ -256,15 +258,37 @@ class PsycopgSyncDriver(
         conn = connection if connection is not None else self._connection(None)
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn, self._get_cursor(txn_conn) as cursor:
-            cursor.execute(script)
+            # Split script into individual statements for validation
+            statements = self._split_script_statements(script)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
+
+            executed_count = 0
+            total_rows = 0
+            last_status = None
+
+            # Execute each statement individually for better control and validation
+            for statement in statements:
+                if statement.strip():
+                    # Validate each statement unless warnings suppressed
+                    if not suppress_warnings:
+                        # Run validation through pipeline
+                        temp_sql = SQL(statement, config=self.config)
+                        temp_sql._ensure_processed()
+                        # Validation errors are logged as warnings by default
+
+                    cursor.execute(statement)
+                    executed_count += 1
+                    total_rows += cursor.rowcount or 0
+                    last_status = cursor.statusmessage
+
             return SQLResult(
                 statement=SQL(script, _dialect=self.dialect).as_script(),
                 data=[],
-                rows_affected=0,
+                rows_affected=total_rows,
                 operation_type="SCRIPT",
-                metadata={"status_message": cursor.statusmessage or "SCRIPT EXECUTED"},
-                total_statements=1,
-                successful_statements=1,
+                metadata={"status_message": last_status or "SCRIPT EXECUTED"},
+                total_statements=executed_count,
+                successful_statements=executed_count,
             )
 
     def _ingest_arrow_table(self, table: "Any", table_name: str, mode: str = "append", **options: Any) -> int:
@@ -471,6 +495,7 @@ class PsycopgSyncDriver(
 
 class PsycopgAsyncDriver(
     AsyncDriverAdapterProtocol[PsycopgAsyncConnection, RowT],
+    AsyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     AsyncStorageMixin,
@@ -485,7 +510,6 @@ class PsycopgAsyncDriver(
         ParameterStyle.NAMED_PYFORMAT,
     )
     default_parameter_style: ParameterStyle = ParameterStyle.POSITIONAL_PYFORMAT
-    __slots__ = ()
 
     def __init__(
         self,
@@ -505,7 +529,7 @@ class PsycopgAsyncDriver(
         self, statement: SQL, connection: Optional[PsycopgAsyncConnection] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return await self._execute_script(sql, connection=connection, **kwargs)
 
         detected_styles = set()
@@ -535,8 +559,7 @@ class PsycopgAsyncDriver(
                 sql = statement.to_sql(placeholder_style=target_style)
                 params = kwargs_params
             else:
-                sql, _ = statement.compile(placeholder_style=target_style)
-                params = statement.parameters
+                sql, params = self._get_compiled_sql(statement, target_style)
             if params is not None:
                 processed_params = [self._process_parameters(param_set) for param_set in params]
                 params = processed_params
@@ -560,7 +583,7 @@ class PsycopgAsyncDriver(
             sql = statement.to_sql(placeholder_style=target_style)
             params = kwargs_params
         else:
-            sql, params = statement.compile(placeholder_style=target_style)
+            sql, params = self._get_compiled_sql(statement, target_style)
         params = self._process_parameters(params)
 
         # Fix over-nested parameters for Psycopg
@@ -683,8 +706,8 @@ class PsycopgAsyncDriver(
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
             # Normalize parameter list using consolidated utility
-            normalized_param_list = normalize_parameter_sequence(param_list)
-            final_param_list = normalized_param_list or []
+            converted_param_list = convert_parameter_sequence(param_list)
+            final_param_list = converted_param_list or []
 
             async with txn_conn.cursor() as cursor:
                 await cursor.executemany(cast("Query", sql), final_param_list)
@@ -703,15 +726,37 @@ class PsycopgAsyncDriver(
         conn = connection if connection is not None else self._connection(None)
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn, txn_conn.cursor() as cursor:
-            await cursor.execute(cast("Query", script))
+            # Split script into individual statements for validation
+            statements = self._split_script_statements(script)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
+
+            executed_count = 0
+            total_rows = 0
+            last_status = None
+
+            # Execute each statement individually for better control and validation
+            for statement in statements:
+                if statement.strip():
+                    # Validate each statement unless warnings suppressed
+                    if not suppress_warnings:
+                        # Run validation through pipeline
+                        temp_sql = SQL(statement, config=self.config)
+                        temp_sql._ensure_processed()
+                        # Validation errors are logged as warnings by default
+
+                    await cursor.execute(cast("Query", statement))
+                    executed_count += 1
+                    total_rows += cursor.rowcount or 0
+                    last_status = cursor.statusmessage
+
             return SQLResult(
                 statement=SQL(script, _dialect=self.dialect).as_script(),
                 data=[],
-                rows_affected=0,
+                rows_affected=total_rows,
                 operation_type="SCRIPT",
-                metadata={"status_message": cursor.statusmessage or "SCRIPT EXECUTED"},
-                total_statements=1,
-                successful_statements=1,
+                metadata={"status_message": last_status or "SCRIPT EXECUTED"},
+                total_statements=executed_count,
+                successful_statements=executed_count,
             )
 
     async def _fetch_arrow_table(self, sql: SQL, connection: "Optional[Any]" = None, **kwargs: Any) -> "ArrowResult":

sqlspec/adapters/sqlite/config.py

@@ -13,7 +13,6 @@ from sqlspec.typing import DictRow
 if TYPE_CHECKING:
     from collections.abc import Generator
 
-    from sqlglot.dialects.dialect import DialectType
 
 logger = logging.getLogger(__name__)
 
@@ -36,26 +35,10 @@ __all__ = ("CONNECTION_FIELDS", "SqliteConfig", "sqlite3")
 class SqliteConfig(NoPoolSyncConfig[SqliteConnection, SqliteDriver]):
     """Configuration for SQLite database connections with direct field-based configuration."""
 
-    __slots__ = (
-        "_dialect",
-        "cached_statements",
-        "check_same_thread",
-        "database",
-        "default_row_type",
-        "detect_types",
-        "extras",
-        "factory",
-        "isolation_level",
-        "pool_instance",
-        "statement_config",
-        "timeout",
-        "uri",
-    )
-
     driver_type: type[SqliteDriver] = SqliteDriver
     connection_type: type[SqliteConnection] = SqliteConnection
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("qmark", "named_colon")
-    preferred_parameter_style: ClassVar[str] = "qmark"
+    default_parameter_style: ClassVar[str] = "qmark"
 
     def __init__(
         self,
@@ -65,7 +48,7 @@ class SqliteConfig(NoPoolSyncConfig[SqliteConnection, SqliteDriver]):
         # SQLite connection parameters
         timeout: Optional[float] = None,
         detect_types: Optional[int] = None,
-        isolation_level: Optional[Union[str, None]] = None,
+        isolation_level: Union[None, str] = None,
         check_same_thread: Optional[bool] = None,
         factory: Optional[type[SqliteConnection]] = None,
         cached_statements: Optional[int] = None,
@@ -106,7 +89,6 @@ class SqliteConfig(NoPoolSyncConfig[SqliteConnection, SqliteDriver]):
         # Store other config
         self.statement_config = statement_config or SQLConfig()
         self.default_row_type = default_row_type
-        self._dialect: DialectType = None
         super().__init__()
 
     @property
@@ -169,6 +151,6 @@ class SqliteConfig(NoPoolSyncConfig[SqliteConnection, SqliteDriver]):
                 statement_config = replace(
                     statement_config,
                     allowed_parameter_styles=self.supported_parameter_styles,
-                    target_parameter_style=self.preferred_parameter_style,
+                    default_parameter_style=self.default_parameter_style,
                 )
             yield self.driver_type(connection=connection, config=statement_config)

sqlspec/adapters/sqlite/driver.py

@@ -12,12 +12,14 @@ from sqlspec.driver import SyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_sync
 from sqlspec.driver.mixins import (
     SQLTranslatorMixin,
+    SyncAdapterCacheMixin,
     SyncPipelinedExecutionMixin,
+    SyncQueryMixin,
     SyncStorageMixin,
     ToSchemaMixin,
     TypeCoercionMixin,
 )
-from sqlspec.driver.parameters import normalize_parameter_sequence
+from sqlspec.driver.parameters import convert_parameter_sequence
 from sqlspec.statement.parameters import ParameterStyle, ParameterValidator
 from sqlspec.statement.result import SQLResult
 from sqlspec.statement.sql import SQL, SQLConfig
@@ -37,10 +39,12 @@ SqliteConnection: TypeAlias = sqlite3.Connection
 
 class SqliteDriver(
     SyncDriverAdapterProtocol[SqliteConnection, RowT],
+    SyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     SyncStorageMixin,
     SyncPipelinedExecutionMixin,
+    SyncQueryMixin,
     ToSchemaMixin,
 ):
     """SQLite Sync Driver Adapter with Arrow/Parquet export support.
@@ -49,8 +53,6 @@ class SqliteDriver(
     instrumentation standards following the psycopg pattern.
     """
 
-    __slots__ = ()
-
     dialect: "DialectType" = "sqlite"
     supported_parameter_styles: "tuple[ParameterStyle, ...]" = (ParameterStyle.QMARK, ParameterStyle.NAMED_COLON)
     default_parameter_style: ParameterStyle = ParameterStyle.QMARK
@@ -106,7 +108,7 @@ class SqliteDriver(
         self, statement: SQL, connection: Optional[SqliteConnection] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return self._execute_script(sql, connection=connection, statement=statement, **kwargs)
 
         detected_styles = set()
@@ -126,17 +128,17 @@ class SqliteDriver(
             target_style = self.default_parameter_style
         elif detected_styles:
             # Single style detected - use it if supported
-            single_style = next(iter(detected_styles))
-            if single_style in self.supported_parameter_styles:
-                target_style = single_style
+            detected_style = next(iter(detected_styles))
+            if detected_style.value in self.supported_parameter_styles:
+                target_style = detected_style
             else:
                 target_style = self.default_parameter_style
 
         if statement.is_many:
-            sql, params = statement.compile(placeholder_style=target_style)
+            sql, params = self._get_compiled_sql(statement, target_style)
             return self._execute_many(sql, params, connection=connection, statement=statement, **kwargs)
 
-        sql, params = statement.compile(placeholder_style=target_style)
+        sql, params = self._get_compiled_sql(statement, target_style)
 
         params = self._process_parameters(params)
 
@@ -153,18 +155,18 @@ class SqliteDriver(
         # Use provided connection or driver's default connection
         conn = connection if connection is not None else self._connection(None)
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn, self._get_cursor(txn_conn) as cursor:
-            # Normalize parameters using consolidated utility
-            normalized_params_list = normalize_parameter_sequence(parameters)
+            # Convert parameters using consolidated utility
+            converted_params_list = convert_parameter_sequence(parameters)
             params_for_execute: Any
-            if normalized_params_list and len(normalized_params_list) == 1:
+            if converted_params_list and len(converted_params_list) == 1:
                 # Single parameter should be tuple for SQLite
-                if not isinstance(normalized_params_list[0], (tuple, list, dict)):
-                    params_for_execute = (normalized_params_list[0],)
+                if not isinstance(converted_params_list[0], (tuple, list, dict)):
+                    params_for_execute = (converted_params_list[0],)
                 else:
-                    params_for_execute = normalized_params_list[0]
+                    params_for_execute = converted_params_list[0]
             else:
                 # Multiple parameters
-                params_for_execute = tuple(normalized_params_list) if normalized_params_list else ()
+                params_for_execute = tuple(converted_params_list) if converted_params_list else ()
 
             cursor.execute(sql, params_for_execute)
             if self.returns_rows(statement.expression):
@@ -199,10 +201,10 @@ class SqliteDriver(
         conn = connection if connection is not None else self._connection(None)
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
             # Normalize parameter list using consolidated utility
-            normalized_param_list = normalize_parameter_sequence(param_list)
+            converted_param_list = convert_parameter_sequence(param_list)
             formatted_params: list[tuple[Any, ...]] = []
-            if normalized_param_list:
-                for param_set in normalized_param_list:
+            if converted_param_list:
+                for param_set in converted_param_list:
                     if isinstance(param_set, (list, tuple)):
                         formatted_params.append(tuple(param_set))
                     elif param_set is None:
@@ -227,12 +229,34 @@ class SqliteDriver(
     def _execute_script(
         self, script: str, connection: Optional[SqliteConnection] = None, statement: Optional[SQL] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
-        """Execute a script on the SQLite connection."""
-        # Use provided connection or driver's default connection
+        """Execute script using splitter for per-statement validation."""
+        from sqlspec.statement.splitter import split_sql_script
+
         conn = connection if connection is not None else self._connection(None)
+        statements = split_sql_script(script, dialect="sqlite")
+
+        total_rows = 0
+        successful = 0
+        suppress_warnings = kwargs.get("_suppress_warnings", False)
+
         with self._get_cursor(conn) as cursor:
-            cursor.executescript(script)
-        # executescript doesn't auto-commit in some cases - force commit
+            for stmt in statements:
+                try:
+                    # Validate each statement unless warnings suppressed
+                    if not suppress_warnings and statement:
+                        # Run validation through pipeline
+                        temp_sql = SQL(stmt, config=statement._config)
+                        temp_sql._ensure_processed()
+                        # Validation errors are logged as warnings by default
+
+                    cursor.execute(stmt)
+                    successful += 1
+                    total_rows += cursor.rowcount or 0
+                except Exception as e:  # noqa: PERF203
+                    if not kwargs.get("continue_on_error", False):
+                        raise
+                    logger.warning("Script statement failed: %s", e)
+
         conn.commit()
 
         if statement is None:
@@ -241,10 +265,10 @@ class SqliteDriver(
         return SQLResult(
             statement=statement,
             data=[],
-            rows_affected=-1,  # Unknown for scripts
+            rows_affected=total_rows,
             operation_type="SCRIPT",
-            total_statements=-1,  # SQLite doesn't provide this info
-            successful_statements=-1,
+            total_statements=len(statements),
+            successful_statements=successful,
             metadata={"status_message": "SCRIPT EXECUTED"},
         )
 

sqlspec/cli.py

@@ -0,0 +1,248 @@
+import sys
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
+
+if TYPE_CHECKING:
+    from click import Group
+
+    from sqlspec.config import AsyncDatabaseConfig, SyncDatabaseConfig
+
+__all__ = ("add_migration_commands", "get_sqlspec_group")
+
+
+def get_sqlspec_group() -> "Group":
+    """Get the SQLSpec CLI group.
+
+    Raises:
+        MissingDependencyError: If the `click` package is not installed.
+
+    Returns:
+        The SQLSpec CLI group.
+    """
+    from sqlspec.exceptions import MissingDependencyError
+
+    try:
+        import rich_click as click
+    except ImportError:
+        try:
+            import click  # type: ignore[no-redef]
+        except ImportError as e:
+            raise MissingDependencyError(package="click", install_package="cli") from e
+
+    @click.group(name="sqlspec")
+    @click.option(
+        "--config",
+        help="Dotted path to SQLAlchemy config(s) (e.g. 'myapp.config.sqlspec_configs')",
+        required=True,
+        type=str,
+    )
+    @click.pass_context
+    def sqlspec_group(ctx: "click.Context", config: str) -> None:
+        """SQLSpec CLI commands."""
+        from rich import get_console
+
+        from sqlspec.utils import module_loader
+
+        console = get_console()
+        ctx.ensure_object(dict)
+        try:
+            config_instance = module_loader.import_string(config)
+            if isinstance(config_instance, Sequence):
+                ctx.obj["configs"] = config_instance
+            else:
+                ctx.obj["configs"] = [config_instance]
+        except ImportError as e:
+            console.print(f"[red]Error loading config: {e}[/]")
+            ctx.exit(1)
+
+    return sqlspec_group
+
+
+def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
+    """Add migration commands to the database group.
+
+    Args:
+        database_group: The database group to add the commands to.
+
+    Raises:
+        MissingDependencyError: If the `click` package is not installed.
+
+    Returns:
+        The database group with the migration commands added.
+    """
+    from sqlspec.exceptions import MissingDependencyError
+
+    try:
+        import rich_click as click
+    except ImportError:
+        try:
+            import click  # type: ignore[no-redef]
+        except ImportError as e:
+            raise MissingDependencyError(package="click", install_package="cli") from e
+    from rich import get_console
+
+    console = get_console()
+
+    if database_group is None:
+        database_group = get_sqlspec_group()
+
+    bind_key_option = click.option(
+        "--bind-key", help="Specify which SQLAlchemy config to use by bind key", type=str, default=None
+    )
+    verbose_option = click.option("--verbose", help="Enable verbose output.", type=bool, default=False, is_flag=True)
+    no_prompt_option = click.option(
+        "--no-prompt",
+        help="Do not prompt for confirmation before executing the command.",
+        type=bool,
+        default=False,
+        required=False,
+        show_default=True,
+        is_flag=True,
+    )
+
+    def get_config_by_bind_key(
+        ctx: "click.Context", bind_key: Optional[str]
+    ) -> "Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]":
+        """Get the SQLAlchemy config for the specified bind key.
+
+        Args:
+            ctx: The click context.
+            bind_key: The bind key to get the config for.
+
+        Returns:
+            The SQLAlchemy config for the specified bind key.
+        """
+        configs = ctx.obj["configs"]
+        if bind_key is None:
+            return cast("Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]", configs[0])
+
+        for config in configs:
+            # Check if config has a name or identifier attribute
+            config_name = getattr(config, "name", None) or getattr(config, "bind_key", None)
+            if config_name == bind_key:
+                return cast("Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]", config)
+
+        console.print(f"[red]No config found for bind key: {bind_key}[/]")
+        sys.exit(1)
+
+    @database_group.command(name="show-current-revision", help="Shows the current revision for the database.")
+    @bind_key_option
+    @verbose_option
+    def show_database_revision(bind_key: Optional[str], verbose: bool) -> None:  # pyright: ignore[reportUnusedFunction]
+        """Show current database revision."""
+        from sqlspec.migrations.commands import MigrationCommands
+
+        ctx = click.get_current_context()
+        console.rule("[yellow]Listing current revision[/]", align="left")
+        sqlspec_config = get_config_by_bind_key(ctx, bind_key)
+        migration_commands = MigrationCommands(config=sqlspec_config)
+        migration_commands.current(verbose=verbose)
+
+    @database_group.command(name="downgrade", help="Downgrade database to a specific revision.")
+    @bind_key_option
+    @no_prompt_option
+    @click.argument("revision", type=str, default="-1")
+    def downgrade_database(  # pyright: ignore[reportUnusedFunction]
+        bind_key: Optional[str], revision: str, no_prompt: bool
+    ) -> None:
+        """Downgrade the database to the latest revision."""
+        from rich.prompt import Confirm
+
+        from sqlspec.migrations.commands import MigrationCommands
+
+        ctx = click.get_current_context()
+        console.rule("[yellow]Starting database downgrade process[/]", align="left")
+        input_confirmed = (
+            True
+            if no_prompt
+            else Confirm.ask(f"Are you sure you want to downgrade the database to the `{revision}` revision?")
+        )
+        if input_confirmed:
+            sqlspec_config = get_config_by_bind_key(ctx, bind_key)
+            migration_commands = MigrationCommands(config=sqlspec_config)
+            migration_commands.downgrade(revision=revision)
+
+    @database_group.command(name="upgrade", help="Upgrade database to a specific revision.")
+    @bind_key_option
+    @no_prompt_option
+    @click.argument("revision", type=str, default="head")
+    def upgrade_database(  # pyright: ignore[reportUnusedFunction]
+        bind_key: Optional[str], revision: str, no_prompt: bool
+    ) -> None:
+        """Upgrade the database to the latest revision."""
+        from rich.prompt import Confirm
+
+        from sqlspec.migrations.commands import MigrationCommands
+
+        ctx = click.get_current_context()
+        console.rule("[yellow]Starting database upgrade process[/]", align="left")
+        input_confirmed = (
+            True
+            if no_prompt
+            else Confirm.ask(f"[bold]Are you sure you want migrate the database to the `{revision}` revision?[/]")
+        )
+        if input_confirmed:
+            sqlspec_config = get_config_by_bind_key(ctx, bind_key)
+            migration_commands = MigrationCommands(config=sqlspec_config)
+            migration_commands.upgrade(revision=revision)
+
+    @database_group.command(help="Stamp the revision table with the given revision")
+    @click.argument("revision", type=str)
+    @bind_key_option
+    def stamp(bind_key: Optional[str], revision: str) -> None:  # pyright: ignore[reportUnusedFunction]
+        """Stamp the revision table with the given revision."""
+        from sqlspec.migrations.commands import MigrationCommands
+
+        ctx = click.get_current_context()
+        sqlspec_config = get_config_by_bind_key(ctx, bind_key)
+        migration_commands = MigrationCommands(config=sqlspec_config)
+        migration_commands.stamp(revision=revision)
+
+    @database_group.command(name="init", help="Initialize migrations for the project.")
+    @bind_key_option
+    @click.argument("directory", default=None, required=False)
+    @click.option("--package", is_flag=True, default=True, help="Create `__init__.py` for created folder")
+    @no_prompt_option
+    def init_sqlspec(  # pyright: ignore[reportUnusedFunction]
+        bind_key: Optional[str], directory: Optional[str], package: bool, no_prompt: bool
+    ) -> None:
+        """Initialize the database migrations."""
+        from rich.prompt import Confirm
+
+        from sqlspec.migrations.commands import MigrationCommands
+
+        ctx = click.get_current_context()
+        console.rule("[yellow]Initializing database migrations.", align="left")
+        input_confirmed = (
+            True if no_prompt else Confirm.ask("[bold]Are you sure you want initialize migrations for the project?[/]")
+        )
+        if input_confirmed:
+            configs = [get_config_by_bind_key(ctx, bind_key)] if bind_key is not None else ctx.obj["configs"]
+            for config in configs:
+                migration_config = getattr(config, "migration_config", {})
+                directory = migration_config.get("script_location", "migrations") if directory is None else directory
+                migration_commands = MigrationCommands(config=config)
+                migration_commands.init(directory=cast("str", directory), package=package)
+
+    @database_group.command(name="make-migrations", help="Create a new migration revision.")
+    @bind_key_option
+    @click.option("-m", "--message", default=None, help="Revision message")
+    @no_prompt_option
+    def create_revision(  # pyright: ignore[reportUnusedFunction]
+        bind_key: Optional[str], message: Optional[str], no_prompt: bool
+    ) -> None:
+        """Create a new database revision."""
+        from rich.prompt import Prompt
+
+        from sqlspec.migrations.commands import MigrationCommands
+
+        ctx = click.get_current_context()
+        console.rule("[yellow]Creating new migration revision[/]", align="left")
+        if message is None:
+            message = "new migration" if no_prompt else Prompt.ask("Please enter a message describing this revision")
+
+        sqlspec_config = get_config_by_bind_key(ctx, bind_key)
+        migration_commands = MigrationCommands(config=sqlspec_config)
+        migration_commands.revision(message=message)
+
+    return database_group