Add NpgsqlDataSource.ReloadTypes{Async} (npgsql#5919)

Author: manandre

src/Npgsql/NpgsqlConnection.cs

@@ -1897,7 +1897,7 @@ public void ReloadTypes()
     /// Flushes the type cache for this connection's connection string and reloads the types for this connection only.
     /// Type changes will appear for other connections only after they are re-opened from the pool.
     /// </summary>
-    public async Task ReloadTypesAsync()
+    public async Task ReloadTypesAsync(CancellationToken cancellationToken = default)
     {
         CheckReady();
 
@@ -1908,7 +1908,7 @@ public async Task ReloadTypesAsync()
             NpgsqlTimeout.Infinite,
             forceReload: true,
             async: true,
-            CancellationToken.None).ConfigureAwait(false);
+            cancellationToken).ConfigureAwait(false);
     }
 
     /// <summary>

src/Npgsql/NpgsqlDataSource.cs

@@ -4,7 +4,6 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Net.Security;
-using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Transactions;
@@ -227,6 +226,29 @@ public static NpgsqlDataSource Create(string connectionString)
     public static NpgsqlDataSource Create(NpgsqlConnectionStringBuilder connectionStringBuilder)
         => Create(connectionStringBuilder.ToString());
 
+    /// <summary>
+    /// Flushes the type cache for this data source.
+    /// Type changes will appear for connections only after they are re-opened from the pool.
+    /// </summary>
+    public void ReloadTypes()
+    {
+        using var connection = OpenConnection();
+        connection.ReloadTypes();
+    }
+
+    /// <summary>
+    /// Flushes the type cache for this data source.
+    /// Type changes will appear for connections only after they are re-opened from the pool.
+    /// </summary>
+    public async Task ReloadTypesAsync(CancellationToken cancellationToken = default)
+    {
+        var connection = await OpenConnectionAsync(cancellationToken).ConfigureAwait(false);
+        await using (connection.ConfigureAwait(false))
+        {
+            await connection.ReloadTypesAsync(cancellationToken).ConfigureAwait(false);
+        }
+    }
+
     internal async Task Bootstrap(
         NpgsqlConnector connector,
         NpgsqlTimeout timeout,

src/Npgsql/PublicAPI.Unshipped.txt

@@ -61,6 +61,10 @@ Npgsql.SslNegotiation
 Npgsql.SslNegotiation.Direct = 1 -> Npgsql.SslNegotiation
 Npgsql.SslNegotiation.Postgres = 0 -> Npgsql.SslNegotiation
 override Npgsql.NpgsqlMultiHostDataSource.Clear() -> void
+Npgsql.NpgsqlDataSource.ReloadTypes() -> void
+Npgsql.NpgsqlDataSource.ReloadTypesAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
+Npgsql.NpgsqlConnection.ReloadTypesAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
+*REMOVED*Npgsql.NpgsqlConnection.ReloadTypesAsync() -> System.Threading.Tasks.Task!
 *REMOVED*Npgsql.NpgsqlDataSourceBuilder.MapComposite(System.Type! clrType, string? pgName = null, Npgsql.INpgsqlNameTranslator? nameTranslator = null) -> Npgsql.TypeMapping.INpgsqlTypeMapper!
 *REMOVED*Npgsql.NpgsqlDataSourceBuilder.MapComposite<T>(string? pgName = null, Npgsql.INpgsqlNameTranslator? nameTranslator = null) -> Npgsql.TypeMapping.INpgsqlTypeMapper!
 *REMOVED*Npgsql.NpgsqlDataSourceBuilder.MapEnum(System.Type! clrType, string? pgName = null, Npgsql.INpgsqlNameTranslator? nameTranslator = null) -> Npgsql.TypeMapping.INpgsqlTypeMapper!

test/Npgsql.Tests/DataSourceTests.cs

@@ -5,6 +5,7 @@
 using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using static Npgsql.Tests.TestUtil;
 
 // ReSharper disable MethodHasAsyncOverload
 
@@ -380,4 +381,72 @@ public async Task ConfigureJsonOptions_is_order_independent()
             Assert.That(reader.GetFieldValue<Test>(0).Id, Is.EqualTo(1));
         }
     }
+
+    [Test]
+    public async Task ReloadTypes([Values] bool async)
+    {
+        await using var adminConnection = await OpenConnectionAsync();
+        var type = await GetTempTypeName(adminConnection);
+
+        var dataSourceBuilder = CreateDataSourceBuilder();
+        dataSourceBuilder.MapEnum<Mood>(type);
+        await using var dataSource = dataSourceBuilder.Build();
+
+        await using var connection = await dataSource.OpenConnectionAsync();
+        await connection.ExecuteNonQueryAsync($"CREATE TYPE {type} AS ENUM ('sad', 'ok', 'happy')");
+
+        if (async)
+            await dataSource.ReloadTypesAsync();
+        else
+            dataSource.ReloadTypes();
+
+        Assert.ThrowsAsync<InvalidCastException>(async () => await connection.ExecuteScalarAsync($"SELECT 'happy'::{type}"));
+
+        // Close connection and reopen to make sure it picks up the new type and mapping from the data source
+        await connection.CloseAsync();
+        await connection.OpenAsync();
+
+        Assert.DoesNotThrowAsync(async () => await connection.ExecuteScalarAsync($"SELECT 'happy'::{type}"));
+    }
+
+    [Test]
+    public async Task ReloadTypes_across_data_sources([Values] bool async)
+    {
+        await using var adminConnection = await OpenConnectionAsync();
+        var type = await GetTempTypeName(adminConnection);
+
+        var dataSourceBuilder = CreateDataSourceBuilder();
+        dataSourceBuilder.MapEnum<Mood>(type);
+        await using var dataSource1 = dataSourceBuilder.Build();
+        await using var connection1 = await dataSource1.OpenConnectionAsync();
+
+        await using var dataSource2 = dataSourceBuilder.Build();
+        await using var connection2 = await dataSource2.OpenConnectionAsync();
+
+        await connection1.ExecuteNonQueryAsync($"CREATE TYPE {type} AS ENUM ('sad', 'ok', 'happy')");
+
+        if (async)
+            await dataSource1.ReloadTypesAsync();
+        else
+            dataSource1.ReloadTypes();
+
+        Assert.ThrowsAsync<InvalidCastException>(async () => await connection1.ExecuteScalarAsync($"SELECT 'happy'::{type}"));
+        Assert.ThrowsAsync<InvalidCastException>(async () => await connection2.ExecuteScalarAsync($"SELECT 'happy'::{type}"));
+
+        // Close connection and reopen to check that the new type and mapping is not available in dataSource2
+        await connection2.CloseAsync();
+        await connection2.OpenAsync();
+
+        Assert.ThrowsAsync<InvalidCastException>(async () => await connection2.ExecuteScalarAsync($"SELECT 'happy'::{type}"));
+
+        await dataSource2.ReloadTypesAsync();
+
+        // Close connection2 and reopen to make sure it picks up the new type and mapping from dataSource2
+        await connection2.CloseAsync();
+        await connection2.OpenAsync();
+
+        Assert.DoesNotThrowAsync(async () => await connection2.ExecuteScalarAsync($"SELECT 'happy'::{type}"));
+    }
+
+    enum Mood { Sad, Ok, Happy }
 }