|
| 1 | +# **Alembic Env** |
| 2 | + |
| 3 | +In the generated migration template, EllarSQL adopts an async-first approach for handling migration file generation. |
| 4 | +This approach simplifies the execution of migrations for both `Session`, `Engine`, `AsyncSession`, and `AsyncEngine`, |
| 5 | +but it also introduces a certain level of complexity. |
| 6 | +```python |
| 7 | +from logging.config import fileConfig |
| 8 | + |
| 9 | +from alembic import context |
| 10 | +from ellar.app import current_injector |
| 11 | +from ellar.threading import execute_coroutine_with_sync_worker |
| 12 | + |
| 13 | +from ellar_sql.migrations import SingleDatabaseAlembicEnvMigration |
| 14 | +from ellar_sql.services import EllarSQLService |
| 15 | + |
| 16 | +# this is the Alembic Config object, which provides |
| 17 | +# access to the values within the .ini file in use. |
| 18 | +config = context.config |
| 19 | + |
| 20 | +# Interpret the config file for Python logging. |
| 21 | +# This line sets up loggers basically. |
| 22 | +fileConfig(config.config_file_name) # type:ignore[arg-type] |
| 23 | + |
| 24 | +# logger = logging.getLogger("alembic.env") |
| 25 | +# other values from the config, defined by the needs of env.py, |
| 26 | +# can be acquired: |
| 27 | +# my_important_option = config.get_main_option("my_important_option") |
| 28 | +# ... etc. |
| 29 | + |
| 30 | + |
| 31 | +async def main() -> None: |
| 32 | + db_service: EllarSQLService = current_injector.get(EllarSQLService) |
| 33 | + |
| 34 | + # initialize migration class |
| 35 | + alembic_env_migration = SingleDatabaseAlembicEnvMigration(db_service) |
| 36 | + |
| 37 | + if context.is_offline_mode(): |
| 38 | + alembic_env_migration.run_migrations_offline(context) # type:ignore[arg-type] |
| 39 | + else: |
| 40 | + await alembic_env_migration.run_migrations_online(context) # type:ignore[arg-type] |
| 41 | + |
| 42 | + |
| 43 | +execute_coroutine_with_sync_worker(main()) |
| 44 | +``` |
| 45 | + |
| 46 | +The EllarSQL migration package provides two main migration classes: |
| 47 | + |
| 48 | +- **SingleDatabaseAlembicEnvMigration**: Manages migrations for a **single** database configuration, catering to both `Engine` and `AsyncEngine`. |
| 49 | +- **MultipleDatabaseAlembicEnvMigration**: Manages migrations for **multiple** database configurations, covering both `Engine` and `AsyncEngine`. |
| 50 | + |
| 51 | +## **Customizing the Env file** |
| 52 | + |
| 53 | +To customize or edit the Env file, it is recommended to inherit from either `SingleDatabaseAlembicEnvMigration` or `MultipleDatabaseAlembicEnvMigration` based on your specific configuration. Make the necessary changes within the inherited class. |
| 54 | + |
| 55 | +If you prefer to write something from scratch, then the abstract class `AlembicEnvMigrationBase` is the starting point. This class includes three abstract methods and expects a `EllarSQLService` during initialization, as demonstrated below: |
| 56 | + |
| 57 | +```python |
| 58 | +class AlembicEnvMigrationBase: |
| 59 | + def __init__(self, db_service: EllarSQLService) -> None: |
| 60 | + self.db_service = db_service |
| 61 | + self.use_two_phase = db_service.migration_options.use_two_phase |
| 62 | + |
| 63 | + @abstractmethod |
| 64 | + def default_process_revision_directives( |
| 65 | + self, |
| 66 | + context: "MigrationContext", |
| 67 | + revision: RevisionArgs, |
| 68 | + directives: t.List["MigrationScript"], |
| 69 | + ) -> t.Any: |
| 70 | + pass |
| 71 | + |
| 72 | + @abstractmethod |
| 73 | + def run_migrations_offline(self, context: "EnvironmentContext") -> None: |
| 74 | + pass |
| 75 | + |
| 76 | + @abstractmethod |
| 77 | + async def run_migrations_online(self, context: "EnvironmentContext") -> None: |
| 78 | + pass |
| 79 | +``` |
| 80 | + |
| 81 | +The `run_migrations_online` and `run_migrations_offline` are all similar to the same function from Alembic env.py template. |
| 82 | +The `default_process_revision_directives` is a callback is used to prevent an auto-migration from being generated |
| 83 | +when there are no changes to the schema described in details [here](http://alembic.zzzcomputing.com/en/latest/cookbook.html) |
| 84 | + |
| 85 | +### Example |
| 86 | +```python |
| 87 | +import logging |
| 88 | +from logging.config import fileConfig |
| 89 | + |
| 90 | +from alembic import context |
| 91 | +from ellar_sql.migrations import AlembicEnvMigrationBase |
| 92 | +from ellar_sql.model.database_binds import get_metadata |
| 93 | +from ellar.app import current_injector |
| 94 | +from ellar.threading import execute_coroutine_with_sync_worker |
| 95 | +from ellar_sql.services import EllarSQLService |
| 96 | + |
| 97 | +# This is the Alembic Config object, which provides |
| 98 | +# access to the values within the .ini file in use. |
| 99 | +config = context.config |
| 100 | +logger = logging.getLogger("alembic.env") |
| 101 | +# Interpret the config file for Python logging. |
| 102 | +# This line sets up loggers essentially. |
| 103 | +fileConfig(config.config_file_name) # type:ignore[arg-type] |
| 104 | + |
| 105 | +class MyCustomMigrationEnv(AlembicEnvMigrationBase): |
| 106 | + def default_process_revision_directives( |
| 107 | + self, |
| 108 | + context, |
| 109 | + revision, |
| 110 | + directives, |
| 111 | + ) -> None: |
| 112 | + if getattr(context.config.cmd_opts, "autogenerate", False): |
| 113 | + script = directives[0] |
| 114 | + if script.upgrade_ops.is_empty(): |
| 115 | + directives[:] = [] |
| 116 | + logger.info("No changes in schema detected.") |
| 117 | + |
| 118 | + def run_migrations_offline(self, context: "EnvironmentContext") -> None: |
| 119 | + """Run migrations in 'offline' mode. |
| 120 | +
|
| 121 | + This configures the context with just a URL |
| 122 | + and not an Engine, though an Engine is acceptable |
| 123 | + here as well. By skipping the Engine creation |
| 124 | + we don't even need a DBAPI to be available. |
| 125 | +
|
| 126 | + Calls to context.execute() here emit the given string to the |
| 127 | + script output. |
| 128 | +
|
| 129 | + """ |
| 130 | + pass |
| 131 | + |
| 132 | + async def run_migrations_online(self, context: "EnvironmentContext") -> None: |
| 133 | + """Run migrations in 'online' mode. |
| 134 | +
|
| 135 | + In this scenario, we need to create an Engine |
| 136 | + and associate a connection with the context. |
| 137 | +
|
| 138 | + """ |
| 139 | + key, engine = self.db_service.engines.popitem() |
| 140 | + metadata = get_metadata(key, certain=True) |
| 141 | + |
| 142 | + conf_args = {} |
| 143 | + conf_args.setdefault( |
| 144 | + "process_revision_directives", self.default_process_revision_directives |
| 145 | + ) |
| 146 | + |
| 147 | + with engine.connect() as connection: |
| 148 | + context.configure( |
| 149 | + connection=connection, |
| 150 | + target_metadata=metadata, |
| 151 | + **conf_args |
| 152 | + ) |
| 153 | + |
| 154 | + with context.begin_transaction(): |
| 155 | + context.run_migrations() |
| 156 | + |
| 157 | +async def main() -> None: |
| 158 | + db_service: EllarSQLService = current_injector.get(EllarSQLService) |
| 159 | + |
| 160 | + # initialize migration class |
| 161 | + alembic_env_migration = MyCustomMigrationEnv(db_service) |
| 162 | + |
| 163 | + if context.is_offline_mode(): |
| 164 | + alembic_env_migration.run_migrations_offline(context) |
| 165 | + else: |
| 166 | + await alembic_env_migration.run_migrations_online(context) |
| 167 | + |
| 168 | +execute_coroutine_with_sync_worker(main()) |
| 169 | +``` |
| 170 | + |
| 171 | +This migration environment class, `MyCustomMigrationEnv`, inherits from `AlembicEnvMigrationBase` |
| 172 | +and provides the necessary methods for offline and online migrations. |
| 173 | +It utilizes the `EllarSQLService` to obtain the database engines and metadata for the migration process. |
| 174 | +The `main` function initializes and executes the migration class, with specific handling for offline and online modes. |
0 commit comments