Multiple Database Migrations Issue with Multi-Tenant Application

[abdullahshaqaliah]

Multiple Database Migrations Issue in Multi-Tenant ABP Application

Overview

We're encountering issues with database migrations in a multi-tenant application where each tenant can connect to up to 3 different databases. The default ABP migration system doesn't properly handle this scenario.

Current Architecture

• Multi-tenant application with ABP Framework
• Each tenant has multiple database connections (up to 3)
• Connection strings stored in TenantConnectionStrings table
• Database Provider: PostgreSQL
• .NET 8

The Problem

The migration system attempts to create all tables in every database connection, regardless of which tables should exist in each database. This leads to errors like:

42P01: relation "PermissionGrants" does not exist
POSITION: 80

Current Database Structure

We have three separate databases per tenant:

1. DMS Database: Contains DMS-specific and identity tables tables
2. Authentication Database: Contains Tenant and OpenIddicttables
3. Administration Database: Contains Permission and Setting and features tables

Current Implementation

EntityFrameworkCoreDMSDbSchemaMigrator

public class EntityFrameworkCoreDMSDbSchemaMigrator
    : IDmsDbSchemaMigrator, ITransientDependency
{
    private readonly IServiceProvider _serviceProvider;

    public EntityFrameworkCoreDMSDbSchemaMigrator(
        IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public async Task MigrateAsync()
    {

        await _serviceProvider
            .GetRequiredService<DMSDbContext>()
            .Database
            .MigrateAsync();

        await _serviceProvider
            .GetRequiredService<AuthenticationDbContext>()
            .Database
            .MigrateAsync();



        await _serviceProvider
            .GetRequiredService<AdministrationServiceDbContext>()
            .Database
            .MigrateAsync();
    }
}

public class DMSDbMigrationService : ITransientDependency
{
    public ILogger<DMSDbMigrationService> Logger { get; set; }

    private readonly IDataSeeder _dataSeeder;
    private readonly IEnumerable<IDmsDbSchemaMigrator> _dbSchemaMigrators;
    private readonly ITenantRepository _tenantRepository;
    private readonly ICurrentTenant _currentTenant;
    private readonly IAbpDistributedLock _distributedLockProvider;


    public DMSDbMigrationService(
        IDataSeeder dataSeeder,
        IEnumerable<IDmsDbSchemaMigrator> dbSchemaMigrators,
        ITenantRepository tenantRepository,
        ICurrentTenant currentTenant,
        IAbpDistributedLock distributedLockProvider)
    {
        _dataSeeder = dataSeeder;
        _dbSchemaMigrators = dbSchemaMigrators;
        _tenantRepository = tenantRepository;
        _currentTenant = currentTenant;

        Logger = NullLogger<DMSDbMigrationService>.Instance;
        _distributedLockProvider = distributedLockProvider;
    }

    public async Task MigrateAsync()


    {
        var databaseName = "DMS";
        Logger.LogInformation("Started database migrations...");

        await using IAbpDistributedLockHandle handle = await _distributedLockProvider.TryAcquireAsync("Migration_" + databaseName);
        Logger.LogInformation("Lock is acquired for db migration and seeding on database named: " + databaseName + "...");
        if (handle == null)
        {
            Logger.LogInformation("Handle is null because of the locking for : " + databaseName);
            return;
        }

        var initialMigrationAdded = AddInitialMigrationIfNotExist();

        if (initialMigrationAdded)
        {
            return;
        }


        await MigrateDatabaseSchemaAsync();
        await SeedDataAsync();

        Logger.LogInformation($"Successfully completed host database migrations.");

        var tenants = await _tenantRepository.GetListAsync(includeDetails: true);

        var migratedDatabaseSchemas = new HashSet<string>();
        foreach (var tenant in tenants)
        {
            using (_currentTenant.Change(tenant.Id))
            {
                if (tenant.ConnectionStrings.Any())
                {
                    var tenantConnectionStrings = tenant.ConnectionStrings
                        .Select(x => x.Value)
                        .ToList();

                    if (!migratedDatabaseSchemas.IsSupersetOf(tenantConnectionStrings))
                    {
                        await MigrateDatabaseSchemaAsync(tenant);

                        migratedDatabaseSchemas.AddIfNotContains(tenantConnectionStrings);
                    }
                }

                await SeedDataAsync(tenant);
            }

            Logger.LogInformation($"Successfully completed {tenant.Name} tenant database migrations.");
        }

        Logger.LogInformation("Successfully completed all database migrations.");
        Logger.LogInformation("You can safely end this process...");
        Logger.LogInformation($"Lock is released for db migration and seeding on database named: {databaseName}...");

    }

    private async Task MigrateDatabaseSchemaAsync(Tenant tenant = null)
    {
        Logger.LogInformation(
            $"Migrating schema for {(tenant == null ? "host" : tenant.Name + " tenant")} database...");

        foreach (var migrator in _dbSchemaMigrators)
        {
            await migrator.MigrateAsync();
        }
    }

    private async Task SeedDataAsync(Tenant tenant = null)
    {
        Logger.LogInformation($"Executing {(tenant == null ? "host" : tenant.Name + " tenant")} database شseed...");

        await _dataSeeder.SeedAsync(new DataSeedContext(tenant?.Id)
            .WithProperty(IdentityDataSeedContributor.AdminEmailPropertyName, "[email protected]")
            .WithProperty(IdentityDataSeedContributor.AdminPasswordPropertyName, IdentityDataSeedContributor.AdminPasswordDefaultValue)
        );
    }

    private bool AddInitialMigrationIfNotExist()
    {
        try
        {
            if (!DbMigrationsProjectExists())
            {
                return false;
            }
        }
        catch (Exception)
        {
            return false;
        }

        try
        {
            if (!MigrationsFolderExists())
            {
                AddInitialMigration();
                return true;
            }
            else
            {
                return false;
            }
        }
        catch (Exception e)
        {
            Logger.LogWarning("Couldn't determinate if any migrations exist : " + e.Message);
            return false;
        }
    }

    private bool DbMigrationsProjectExists()
    {
        var dbMigrationsProjectFolder = GetEntityFrameworkCoreProjectFolderPath();

        return dbMigrationsProjectFolder != null;
    }

    private bool MigrationsFolderExists()
    {
        var dbMigrationsProjectFolder = GetEntityFrameworkCoreProjectFolderPath();
        return dbMigrationsProjectFolder != null && Directory.Exists(Path.Combine(dbMigrationsProjectFolder, "Migrations"));
    }

    private void AddInitialMigration()
    {
        Logger.LogInformation("Creating initial migration...");

        string argumentPrefix;
        string fileName;

        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) || RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            argumentPrefix = "-c";
            fileName = "/bin/bash";
        }
        else
        {
            argumentPrefix = "/C";
            fileName = "cmd.exe";
        }

        var procStartInfo = new ProcessStartInfo(fileName,
            $"{argumentPrefix} \"abp create-migration-and-run-migrator \"{GetEntityFrameworkCoreProjectFolderPath()}\"\""
        );

        try
        {
            Process.Start(procStartInfo);
        }
        catch (Exception)
        {
            throw new Exception("Couldn't run ABP CLI...");
        }
    }

    private string GetEntityFrameworkCoreProjectFolderPath()
    {
        var slnDirectoryPath = GetSolutionDirectoryPath();

        if (slnDirectoryPath == null)
        {
            throw new Exception("Solution folder not found!");
        }

        var srcDirectoryPath = Path.Combine(slnDirectoryPath, "src");

        return Directory.GetDirectories(srcDirectoryPath)
            .FirstOrDefault(d => d.EndsWith(".EntityFrameworkCore"));
    }

    private string GetSolutionDirectoryPath()
    {
        var currentDirectory = new DirectoryInfo(Directory.GetCurrentDirectory());

        while (currentDirectory != null && Directory.GetParent(currentDirectory.FullName) != null)
        {
            currentDirectory = Directory.GetParent(currentDirectory.FullName);

            if (currentDirectory != null && Directory.GetFiles(currentDirectory.FullName).FirstOrDefault(f => f.EndsWith(".sln")) != null)
            {
                return currentDirectory.FullName;
            }
        }

        return null;
    }
}

What We Need

1. A way to map specific modules to their respective databases
2. Proper migration sequence handling for new tenants
3. Mechanism to ensure each database only receives relevant migrations

Questions

1. What's the recommended approach for handling migrations with multiple database connections per tenant?
2. How can we configure module-to-database mapping for migrations?
3. Is there a way to extend ABP's default migration behavior for this scenario?

Additional Notes

• The system works correctly with single database per tenant
• We need to maintain separate schemas for different modules
• Looking for best practices in managing multiple databases in ABP's multi-tenant architecture

Environment Details

• ABP Version:9.0.4
• Database: PostgreSQL
• Platform: Windows
• Framework: .NET 9

---

Tags

#abp #efcore #migrations #multi-tenant #postgresql #dotnet

@maliming

[abdullahshaqaliah]

@maliming ???

[maliming]

Please check the document https://abp.io/docs/latest/framework/data/entity-framework-core/migrations

[abdullahshaqaliah]

I have a multi-tenant application with two different DbContexts for tenants:

Host and Tenant DbContexts:

[ConnectionStringName("AdministrationService")]
public class AdministrationServiceHostDbContext : AbpDbContext<AdministrationServiceHostDbContext>
{
    protected override void OnModelCreating(ModelBuilder builder)
    {
        builder.SetMultiTenancySide(MultiTenancySides.Host);
        // Configure tables...
    }
}

[ConnectionStringName("AdministrationService")]
public class AdministrationServiceTenantDbContext : AbpDbContext<AdministrationServiceTenantDbContext>
{
    protected override void OnModelCreating(ModelBuilder builder)
    {
        builder.SetMultiTenancySide(MultiTenancySides.Tenant);
        // Configure tables...
    }
}

Tenant Connection Strings (stored in database):

Migrations work correctly using this code:

public class TenantDmsDbSchemaMigrator : ITenantDmsDbSchemaMigrator,ITransientDependency
{
    private readonly ICurrentTenant _currentTenant;
    private readonly IDataSeeder _dataSeeder;
    private ILogger<TenantDmsDbSchemaMigrator> _logger { get; set; }
    public TenantDmsDbSchemaMigrator(ICurrentTenant currentTenant, ILogger<TenantDmsDbSchemaMigrator> logger, IDataSeeder dataSeeder)
    {
        _currentTenant = currentTenant;
        _logger = logger;
        _dataSeeder = dataSeeder;
    }

    public async Task MigrateAsync(Tenant tenant, string userNameOrEmail, string password)
    {
        using (_currentTenant.Change(tenant.Id))
        {
            if (tenant.ConnectionStrings.Any())
            {
                var dmsConnectionString = tenant.ConnectionStrings
                                                .Where(e => e.Name.Equals("Default", StringComparison.OrdinalIgnoreCase))
                                                .FirstOrDefault();

                if (dmsConnectionString != null)
                {
                    await MigrateTenantDmsDatabaseSchemaAsync(tenant, dmsConnectionString);

                }

                var administratioConnectionString = tenant.ConnectionStrings
                    .Where(e => e.Name.Equals("AdministrationService", StringComparison.OrdinalIgnoreCase))
                    .FirstOrDefault();

                if (administratioConnectionString != null)
                {
                    await MigrateTenantAdministrationDatabaseSchemaAsync(tenant, administratioConnectionString);

                }
            }

            await _dataSeeder.SeedAsync(new DataSeedContext(tenant.Id)
                .WithProperty(IdentityDataSeedContributor.AdminEmailPropertyName, userNameOrEmail)
                .WithProperty(IdentityDataSeedContributor.AdminPasswordPropertyName, password)
            );
        }

    }

    private async Task MigrateTenantDmsDatabaseSchemaAsync(Tenant tenant, TenantConnectionString tenantConnectionString)
    {
        _logger.LogInformation(
            $"Migrating schema for {tenant.Name} tenant database {tenantConnectionString.Name}");
        var db = CreateDbContext<TenantDMSDbContext>(tenantConnectionString.Value, x => x.UseNetTopologySuite());
        await db.Database.MigrateAsync();

    }

    private async Task MigrateTenantAdministrationDatabaseSchemaAsync(Tenant tenant, TenantConnectionString tenantConnectionString)
    {
        _logger.LogInformation(
            $"Migrating schema for {tenant.Name} tenant database {tenantConnectionString.Name}");
        var db = CreateDbContext<AdministrationServiceTenantDbContext>(tenantConnectionString.Value);
        await db.Database.MigrateAsync();

    }

    private TDbContext CreateDbContext<TDbContext>(
    string connectionString,
    Action<NpgsqlDbContextOptionsBuilder> npgsqlOptionsAction = null)
    where TDbContext : AbpDbContext<TDbContext>
    {
        AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);

        var builder = new DbContextOptionsBuilder<TDbContext>()
            .UseNpgsql(connectionString, optionsBuilder =>
            {
                npgsqlOptionsAction?.Invoke(optionsBuilder);
            });

        return (TDbContext)Activator.CreateInstance(
            typeof(TDbContext),
            builder.Options);
    }
}

Database Connection Mappings in Module:

Configure<AbpDbConnectionOptions>(options =>
{
    options.Databases.Configure("AdministrationService", database =>
    {
        // Map all required module connections
        database.MappedConnections.Add("AbpAuditLogging");
        database.MappedConnections.Add("AbpPermissionManagement");
        database.MappedConnections.Add("AbpSettingManagement");
        database.MappedConnections.Add("AbpFeatureManagement");
        database.MappedConnections.Add("StorageManagement");
    });
});

When querying data through repositories, even though I have specified [ConnectionStringName("AdministrationService")] on the DbContext, it always uses the "Default" connection string from tenant connection strings instead of the "AdministrationService" connection string. This causes the error:

Npgsql.PostgresException (0x80004005): 42P01: relation "PermissionGrants" does not exist

The migrations execute correctly and create the tables in the proper database, but when querying, it's using the wrong connection string.
How can I make the tenant DbContext use its specified connection string ("AdministrationService") instead of defaulting to the "Default" connection string?
Any help would be appreciated.

@maliming

[maliming]

You can override this class and set a break point to debug it to see why your tenant connection string is unresolved.

https://github.com/abpframework/abp/blob/dev/framework/src/Volo.Abp.MultiTenancy/Volo/Abp/MultiTenancy/MultiTenantConnectionStringResolver.cs#L12

[abdullahshaqaliah]

@maliming I fixed the issue about resolved. connection string and I have another issue

I have an issue with the EventBus (Outbox/Inbox) always using the Host DbContext instead of the Tenant DbContext. Here's my setup:

Host DbContext:

[ReplaceDbContext(typeof(IIdentityDbContext))]
[ConnectionStringName("Default")]
public class HostDMSDbContext : EraTechDbContext<HostDMSDbContext>, 
    IIdentityDbContext, 
    IHasEventInbox, 
    IHasEventOutbox
{
    // Event tables
    public DbSet<OutgoingEventRecord> OutgoingEvents { get; set; }
    public DbSet<IncomingEventRecord> IncomingEvents { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.SetMultiTenancySide(MultiTenancySides.Host);
        modelBuilder.ConfigureEventOutbox();
        modelBuilder.ConfigureEventInbox();
        // ...
    }
}

Tenant DbContext:

[ConnectionStringName("Default")]
public class TenantDMSDbContext : EraTechDbContext<TenantDMSDbContext>
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.SetMultiTenancySide(MultiTenancySides.Tenant);
        // ...
    }
}

The issue is that when a tenant operation triggers an event, it always tries to use the Host DbContext for EventOutbox/Inbox operations, even though we're in a tenant context. This causes the following error:

Npgsql.PostgresException (0x80004005): 42P01: relation "EventOutbox" does not exist

This happens because it's trying to access the EventOutbox table in the tenant database when the table is only configured in the Host DbContext.
Questions:

1. How can we make EventBus respect the current tenant context?
2. Should we implement IHasEventInbox and IHasEventOutbox in the Tenant DbContext as well?
3. Is this the expected behavior or should EventBus automatically use the correct DbContext based on the current tenant?

Any guidance would be appreciated.

[maliming]

What is your Configure<AbpDistributedEventBusOptions> code?

[abdullahshaqaliah]

        Configure<AbpDistributedEventBusOptions>(options =>
        {
            options.Outboxes.Configure(config =>
            {
                config.UseDbContext<HostDMSDbContext>();
            });
            options.Inboxes.Configure(config =>
            {
                config.UseDbContext<HostDMSDbContext>();
            });
        });

@maliming

[maliming]

config.UseDbContext<HostDMSDbContext>(); specifies the DbContext, which is static by default.

https://github.com/abpframework/abp/blob/dev/framework/src/Volo.Abp.EventBus/Volo/Abp/EventBus/Distributed/OutboxSender.cs#L53

[abdullahshaqaliah]

Thanks for your response. However, I'm not quite clear about the solution. You mentioned:

config.UseDbContext<HostDMSDbContext>(); specifies the DbContext, which is static by default.

Could you please provide a complete example of how we should configure this correctly? We have:

1. A Host database where EventOutbox/Inbox tables should exist
2. Multiple tenant databases that shouldn't contain these tables
3. Events being triggered from both Host and Tenant contexts

What's the proper way to ensure that all events (whether triggered from Host or Tenant context) are always stored in the Host database's EventOutbox/Inbox tables?

If possible, could you share a working example of the correct configuration for this scenario?
@maliming

[maliming]

ensure that all events (whether triggered from Host or Tenant context) are always stored in the Host database's EventOutbox/Inbox tables

The code you shared is correct. It will use HostDMSDbContext as implementaion.

Configure<AbpDistributedEventBusOptions>(options =>
{
    options.Outboxes.Configure(config =>
    {
        config.UseDbContext<HostDMSDbContext>();
    });
    options.Inboxes.Configure(config =>
    {
        config.UseDbContext<HostDMSDbContext>();
    });
});

The issue is that when a tenant operation triggers an event, it always tries to use the Host DbContext for EventOutbox/Inbox operations, even though we're in a tenant context. This causes the following error:

Please share full error stack.

[abdullahshaqaliah]

Both our Host and Tenant DbContexts use "Default" as connection string name:

[ConnectionStringName("Default")]
public class HostDMSDbContext : EraTechDbContext<HostDMSDbContext>
{...}

[ConnectionStringName("Default")]
public class TenantDMSDbContext : EraTechDbContext<TenantDMSDbContext>
{...}

I think the main problem is that when in tenant context, it tries to get connection string from tenant as "Default" connection string name, causing this error:

 Started database migrations...
[07:20:52 INF] Lock is acquired for db migration and seeding on database named: DMS...
[07:20:52 INF] Migrating schema for host database...
[07:20:55 INF] Executing host database seed...
[07:21:02 INF] Successfully completed host database migrations.
[07:21:02 INF] Migrating schema for T1 tenant database Default
[07:21:02 INF] Migrating schema for T1 tenant database AdministrationService
[07:21:25 ERR] Failed executing DbCommand (324ms) [Parameters=[@p0='?' (DbType = Guid), @p1='?' (DbType = DateTime), @p2='?' (DbType = Binary), @p3='?', @p4='?', @p5='?' (DbType = Guid), @p6='?' (DbType = DateTime), @p7='?' (DbType = Binary), @p8='?', @p9='?', @p10='?' (DbType = Guid), @p11='?' (DbType = DateTime), @p12='?' (DbType = Binary), @p13='?', @p14='?', @p15='?' (DbType = Guid), @p16='?' (DbType = DateTime), @p17='?' (DbType = Binary), @p18='?', @p19='?'], CommandType='Text', CommandTimeout='30']
INSERT INTO "EventOutbox" ("Id", "CreationTime", "EventData", "EventName", "ExtraProperties")
VALUES (@p0, @p1, @p2, @p3, @p4);
INSERT INTO "EventOutbox" ("Id", "CreationTime", "EventData", "EventName", "ExtraProperties")
VALUES (@p5, @p6, @p7, @p8, @p9);
INSERT INTO "EventOutbox" ("Id", "CreationTime", "EventData", "EventName", "ExtraProperties")
VALUES (@p10, @p11, @p12, @p13, @p14);
INSERT INTO "EventOutbox" ("Id", "CreationTime", "EventData", "EventName", "ExtraProperties")
VALUES (@p15, @p16, @p17, @p18, @p19);
[07:21:25 ERR] An exception occurred in the database while saving changes for context type 'EraTech.DMS.Core.EntityFrameworkCore.HostDMSDbContext'.
Microsoft.EntityFrameworkCore.DbUpdateException: An error occurred while saving the entity changes. See the inner exception for details.
 ---> Npgsql.PostgresException (0x80004005): 42P01: relation "EventOutbox" does not exist

POSITION: 13
   at Npgsql.Internal.NpgsqlConnector.ReadMessageLong(Boolean async, DataRowLoadingMode dataRowLoadingMode, Boolean readingNotifications, Boolean isReadingPrependedMessage)
   at System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.StateMachineBox`1.System.Threading.Tasks.Sources.IValueTaskSource<TResult>.GetResult(Int16 token)
   at Npgsql.NpgsqlDataReader.NextResult(Boolean async, Boolean isConsuming, CancellationToken cancellationToken)
   at Npgsql.NpgsqlDataReader.NextResult(Boolean async, Boolean isConsuming, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteReader(Boolean async, CommandBehavior behavior, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteReader(Boolean async, CommandBehavior behavior, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteDbDataReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReaderAsync(RelationalCommandParameterObject parameterObject, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReaderAsync(RelationalCommandParameterObject parameterObject, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken)
  Exception data:
    Severity: ERROR
    SqlState: 42P01
    MessageText: relation "EventOutbox" does not exist
    Position: 13
    File: parse_relation.c
    Line: 1452
    Routine: parserOpenTable
   --- End of inner exception stack trace ---
   at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalDatabase.SaveChangesAsync(IList`1 entries, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.SaveChangesAsync(IList`1 entriesToSave, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.SaveChangesAsync(StateManager stateManager, Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Npgsql.EntityFrameworkCore.PostgreSQL.Storage.Internal.NpgsqlExecutionStrategy.ExecuteAsync[TState,TResult](TState state, Func`4 operation, Func`4 verifySucceeded, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.DbContext.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
Microsoft.EntityFrameworkCore.DbUpdateException: An error occurred while saving the entity changes. See the inner exception for details.
 ---> Npgsql.PostgresException (0x80004005): 42P01: relation "EventOutbox" does not exist

POSITION: 13
   at Npgsql.Internal.NpgsqlConnector.ReadMessageLong(Boolean async, DataRowLoadingMode dataRowLoadingMode, Boolean readingNotifications, Boolean isReadingPrependedMessage)
   at System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.StateMachineBox`1.System.Threading.Tasks.Sources.IValueTaskSource<TResult>.GetResult(Int16 token)
   at Npgsql.NpgsqlDataReader.NextResult(Boolean async, Boolean isConsuming, CancellationToken cancellationToken)
   at Npgsql.NpgsqlDataReader.NextResult(Boolean async, Boolean isConsuming, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteReader(Boolean async, CommandBehavior behavior, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteReader(Boolean async, CommandBehavior behavior, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteDbDataReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReaderAsync(RelationalCommandParameterObject parameterObject, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReaderAsync(RelationalCommandParameterObject parameterObject, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken)
  Exception data:
    Severity: ERROR
    SqlState: 42P01
    MessageText: relation "EventOutbox" does not exist
    Position: 13
    File: parse_relation.c
    Line: 1452
    Routine: parserOpenTable
   --- End of inner exception stack trace ---
   at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalDatabase.SaveChangesAsync(IList`1 entries, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.SaveChangesAsync(IList`1 entriesToSave, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.SaveChangesAsync(StateManager stateManager, Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Npgsql.EntityFrameworkCore.PostgreSQL.Storage.Internal.NpgsqlExecutionStrategy.ExecuteAsync[TState,TResult](TState state, Func`4 operation, Func`4 verifySucceeded, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.DbContext.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.DbContext.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Volo.Abp.EntityFrameworkCore.AbpDbContext`1.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Volo.Abp.Uow.UnitOfWork.SaveChangesAsync(CancellationToken cancellationToken)
   at Volo.Abp.Uow.UnitOfWork.CompleteAsync(CancellationToken cancellationToken)
   at Volo.Abp.Uow.UnitOfWorkInterceptor.InterceptAsync(IAbpMethodInvocation invocation)
[07:21:28 FTL] Host terminated unexpectedly!
Volo.Abp.AbpInitializationException: An error occurred during the initialize Volo.Abp.Modularity.OnPreApplicationInitializationModuleLifecycleContributor phase of the module EraTech.DMS.DMSHttpApiHostModule, EraTech.DMS.HttpApi.Host, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null: An error occurred while saving the entity changes. See the inner exception for details.. See the inner exception for details.
 ---> Microsoft.EntityFrameworkCore.DbUpdateException: An error occurred while saving the entity changes. See the inner exception for details.
 ---> Npgsql.PostgresException (0x80004005): 42P01: relation "EventOutbox" does not exist

POSITION: 13
   at Npgsql.Internal.NpgsqlConnector.ReadMessageLong(Boolean async, DataRowLoadingMode dataRowLoadingMode, Boolean readingNotifications, Boolean isReadingPrependedMessage)
   at System.Runtime.CompilerServices.PoolingAsyncValueTaskMethodBuilder`1.StateMachineBox`1.System.Threading.Tasks.Sources.IValueTaskSource<TResult>.GetResult(Int16 token)
   at Npgsql.NpgsqlDataReader.NextResult(Boolean async, Boolean isConsuming, CancellationToken cancellationToken)
   at Npgsql.NpgsqlDataReader.NextResult(Boolean async, Boolean isConsuming, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteReader(Boolean async, CommandBehavior behavior, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteReader(Boolean async, CommandBehavior behavior, CancellationToken cancellationToken)
   at Npgsql.NpgsqlCommand.ExecuteDbDataReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReaderAsync(RelationalCommandParameterObject parameterObject, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReaderAsync(RelationalCommandParameterObject parameterObject, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken)
  Exception data:
    Severity: ERROR
    SqlState: 42P01
    MessageText: relation "EventOutbox" does not exist
    Position: 13
    File: parse_relation.c
    Line: 1452
    Routine: parserOpenTable
   --- End of inner exception stack trace ---
   at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable`1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalDatabase.SaveChangesAsync(IList`1 entries, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.SaveChangesAsync(IList`1 entriesToSave, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.SaveChangesAsync(StateManager stateManager, Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Npgsql.EntityFrameworkCore.PostgreSQL.Storage.Internal.NpgsqlExecutionStrategy.ExecuteAsync[TState,TResult](TState state, Func`4 operation, Func`4 verifySucceeded, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.DbContext.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.DbContext.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Volo.Abp.EntityFrameworkCore.AbpDbContext`1.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken)
   at Volo.Abp.Uow.UnitOfWork.SaveChangesAsync(CancellationToken cancellationToken)
   at Volo.Abp.Uow.UnitOfWork.CompleteAsync(CancellationToken cancellationToken)
   at Volo.Abp.Uow.UnitOfWorkInterceptor.InterceptAsync(IAbpMethodInvocation invocation)
   at Volo.Abp.Castle.DynamicProxy.CastleAsyncAbpInterceptorAdapter`1.InterceptAsync(IInvocation invocation, IInvocationProceedInfo proceedInfo, Func`3 proceed)
   at EraTech.DMS.Core.EntityFrameworkCore.TenantDmsDbSchemaMigrator.MigrateAsync(Tenant tenant, String userNameOrEmail, String password) in F:\EraTech\EraTech.DMS\src\core\EraTech.DMS.Core.EntityFrameworkCore\EntityFrameworkCore\TenantDmsDbSchemaMigrator.cs:line 57
   at DMSDbMigrationService.MigrateAsync() in F:\EraTech\EraTech.DMS\src\services\admin\EraTech.DMS.HttpApi.Host\DbMigrations\DMSDbMigrationService.cs:line 80
   at DMSDbMigrationService.MigrateAsync() in F:\EraTech\EraTech.DMS\src\services\admin\EraTech.DMS.HttpApi.Host\DbMigrations\DMSDbMigrationService.cs:line 87
   at Volo.Abp.Modularity.OnPreApplicationInitializationModuleLifecycleContributor.InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
   at Volo.Abp.Modularity.ModuleManager.InitializeModulesAsync(ApplicationInitializationContext context)
   --- End of inner exception stack trace ---
   at Volo.Abp.Modularity.ModuleManager.InitializeModulesAsync(ApplicationInitializationContext context)
   at Volo.Abp.AbpApplicationBase.InitializeModulesAsync()
   at Volo.Abp.AbpApplicationWithExternalServiceProvider.InitializeAsync(IServiceProvider serviceProvider)
   at Microsoft.AspNetCore.Builder.AbpApplicationBuilderExtensions.InitializeApplicationAsync(IApplicationBuilder app)
   at EraTech.DMS.Program.Main(String[] args) in F:\EraTech\EraTech.DMS\src\services\admin\EraTech.DMS.HttpApi.Host\Program.cs:line 35

F:\EraTech\EraTech.DMS\src\services\admin\EraTech.DMS.HttpApi.Host\bin\Debug\net9.0\EraTech.DMS.HttpApi.Host.exe (process 33632) exited with code 1 (0x1).
To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.
Press any key to close this window . . .

Should we use a different connection string name for the Host DbContext to resolve this?
@maliming

[maliming]

Can you share your project source code?

I can't understand your current situation