FastAPI Database Migrations with Alembic and SQLAlchemy

This section covers Alembic migration management and containerized deployment strategies. Alembic manages database schema changes through migration files generated using 'alembic revision --autogenerate'. Migrations must be committed to version control for production deployment. Test migrations should be removed from version control. Containerized migration execution requires dedicated containers depending only on the database service, with sleep delays to ensure database initialization. Shell scripts need execute permissions. Database URLs should be configured through environment variables for flexibility across environments.

Alembic is a database migration tool that works with SQLAlchemy to automatically generate and apply schema changes to databases; the workflow involves initializing Alembic, configuring the database URL and metadata in the env.py file, running 'alembic revision --autogenerate' to create upgrade/downgrade scripts, and executing 'alembic upgrade head' to apply migrations, ensuring the database schema always matches the application's model definitions.

Database migrations in engines require mounting into the main app rather than copying, using Rails migration system parameters. For testing, use Combustion to create minimal test applications with only needed frameworks, managing migrations automatically. For CI/CD, implement a 'dirty' check script that builds an inverted index of engine specifications and dependencies to determine if tests need running. This approach optimizes CI builds by only running tests for changed components and their dependencies.

Alembic is a database migration tool that automatically detects and applies changes between SQLAlchemy declarative models and the actual database schema through a version-controlled revision system, allowing developers to create, upgrade, and downgrade database schemas systematically by generating migration scripts that track changes over time.

Django allows developers to write custom migration functions for data transformation. Custom migrations use the migrations module with Python functions that execute during migration. For example, to combine two fields (name and age) into a single name field, developers write a function that iterates through all records and updates the name field by concatenating the values. This is useful for schema changes that require data transformation, such as merging multiple fields into one or converting data formats.

Data migrations follow the same class structure as schema migrations, using the Migration superclass with dependencies and operations. The runpython operation executes Python functions to add or remove data. Test data is stored as a list of dictionaries with name-value pairs, often including a disambiguator field to mark test records. Functions are configured by passing their names as strings, following the Hollywood Principle where the migration system calls the configured functions. The add function creates records while the remove function deletes them, enabling bidirectional data management.

Custom migrations require implementing SchemaMigrationPlan with schemas and stages. Stages specify source and target versions, with willMigrate providing access to the source schema and didMigrate providing access to the target schema. In didMigrate, developers fetch existing records, transform them according to requirements, and save changes using context.save(). The instructor demonstrates adding a description field with calculated values to existing budget records. After configuring ModelContainer with the migration plan, SwiftData automatically executes migrations when schema versions change. This enables intelligent data transformation during schema evolution.

Schema migrations should only change the database structure (tables, columns, constraints), not populate data. Data seeding should be handled separately using Hasura's seeds feature or manual data insertion. A best practice is to add baseline data after schema migrations are applied, not during schema changes. This ensures data is consistent with the current schema state. If you add data during schema migrations, any schema changes could break the data or cause inconsistencies.

The speaker demonstrates creating custom migrations instead of using EF's auto-generated migrations. This involves writing C# classes that specify database schema changes including tables, columns, constraints, and indexes. The speaker emphasizes adding indexes on frequently queried columns like VIN and PersonID for performance. Custom migrations provide more control over database schema and allow for complex configurations that auto-generated migrations cannot handle.

Every repository needs a main branch (master/main) containing stable, tested code for production. When developing features, create new feature branches from the latest master version since fundamental changes require time and produce unstable code. For large features, create sub-branches for parallel development among team members to prevent conflicts. After completing components, merge sub-branches back into the feature branch, then merge the feature branch into master after testing. Pull requests prevent developers from directly merging untested code into master. The workflow involves pushing your branch to GitHub, creating a pull request specifying source and target branches, adding a title and description. Other developers can view all changes and leave comments under specific code lines, providing valuable feedback. After making necessary changes and pushing, the pull request updates automatically. Once approved by team members, you can merge your branch into master. Cherry-pick applies a specific commit from one branch to another without bringing in all other commits. Merge conflicts occur when two developers modify the same file in the same way simultaneously. Git cannot automatically resolve conflicts because it doesn't understand business logic. Only humans can resolve conflicts because they understand the code's purpose. Modern IDEs provide graphical interfaces showing conflicted files. The merge tool displays three versions: left (your branch), right (merged branch), and middle (result). You can accept lines from either side by clicking icons, or edit the middle window directly. After resolving, click 'Apply' to complete the merge and commit automatically.

Git branches are lightweight pointers to commits that enable parallel development, where the HEAD pointer indicates the current branch; merging integrates changes through fast-forward merges (when one branch is directly ahead) or 3-way merges (when branches diverge), with conflicts arising when both branches modify the same lines, requiring manual resolution by editing conflict markers and committing the result; the git stash command temporarily saves uncommitted changes to avoid conflicts during branch switching.

When multiple developers collaborate on the same repository, conflicts occur when they simultaneously modify the same files; these conflicts are resolved through 3-way merge, which combines changes from both branches while preserving the common ancestor, and developers can use pull or pull --rebase commands to synchronize their local branches with the remote repository before pushing their changes.

This section focuses on collaborative workflows and resolving conflicts when multiple people work on the same code. Scott demonstrates merging branches with git merge, explaining fast-forward merges when no conflicts occur. He then shows how conflicts arise when multiple branches modify the same lines of code, displaying Git's conflict markers and requiring manual resolution. The process involves editing conflicted files, choosing which changes to keep, staging resolutions with git add, and completing the merge with git commit. Scott emphasizes that understanding this workflow is essential for team collaboration, as it handles the inevitable situations where parallel development paths converge. The section concludes by reinforcing Git's fundamental strength as a time machine for recovering work and maintaining project history integrity.

In collaborative software development, team members work on isolated feature branches created from the main development branch to prevent contaminating shared code. Each developer creates their own branch using `git checkout -b <branch-name>`. Conflicts arise when two branches have modified identical lines—the 'double novelty' problem where both branches contain new changes to the same location, making it physically impossible for both versions to coexist. Understanding this fundamental principle is essential for effective team collaboration and code management.