Can't write arrays of user-defined ranges

[NazarPolevyi]

Steps to reproduce

Hi, after Npgsql.EntityFrameworkCore.PostgreSQL update from to 7.0.4 to 8.0.2. We have started to receive an exception when saving into db.
InvalidCastException: Writing values of 'NpgsqlTypes.NpgsqlRange`1[[System.TimeSpan, System.Private.CoreLib, Version=8.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]][]' is not supported for parameters having NpgsqlDbType '-2147483608'.

public class RestrictionSettings
{
    [Column("id")]
    public Guid Id { get; set; }

    [Column("allowed_time_ranges", TypeName = "timerange[]")]
    public NpgsqlRange<TimeSpan>[]? AllowedTimeRanges { get; set; }
}

private readonly NpgsqlDataSource _dataSource;
private readonly ILoggerFactory _loggerFactory;

public class CustomDbContext : DbContext
{
    private readonly NpgsqlDataSource _dataSource;
    private readonly ILoggerFactory _loggerFactory;

    public CustomDbContext (NpgsqlDataSource dataSource, ILoggerFactory loggerFactory)
    {
        _dataSource = dataSource;
        _loggerFactory = loggerFactory;
    }

    public DbSet<RestrictionSettings> RestrictionSettings{ get; set; }

  protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  {
      if (!optionsBuilder.IsConfigured)
      {
          optionsBuilder
              .UseLoggerFactory(_loggerFactory)
              .UseNpgsql(
                  _dataSource,
                  o => o
                      .SetPostgresVersion(new Version(10, 21))
                      .MapRange<TimeSpan>("timerange", subtypeName: "time without time zone"));

          optionsBuilder
              .EnableDetailedErrors()
              .EnableSensitiveDataLogging();
      }
  }

 protected override void OnModelCreating(ModelBuilder modelBuilder)
 {
     modelBuilder.HasPostgresRange(name: "timerange", subtype: "time without time zone");
  }
}

Registration example

  services.AddSingleton<Func<CustomDbContext>>(p => () =>
      {
          var connectionString = "connection string";

          var dataSourceBuilder = new NpgsqlDataSourceBuilder(connectionString);
          dataSourceBuilder.EnableDynamicJson().EnableUnmappedTypes();
          var dataSource = dataSourceBuilder.Build();

          return new CustomDbContext (
              dataSource,
              p.GetRequiredService<ILoggerFactory>());
      });

The timerange it's a custom timerange type:

` CREATE FUNCTION time_subtype_diff(x time, y time) RETURNS float8 AS
'SELECT EXTRACT(EPOCH FROM (x - y))' LANGUAGE sql STRICT IMMUTABLE;

CREATE TYPE timerange AS RANGE (
    subtype = time without time zone,
    subtype_diff = time_subtype_diff
);`

How can we solve this error? Before update it was working,

Exception message:
`Microsoft.EntityFrameworkCore.DbUpdateException
  HResult=0x80131500
  Message=An error occurred while saving the entity changes. See the inner exception for details.
  Source=Microsoft.EntityFrameworkCore.Relational
  StackTrace:
   at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.<ExecuteAsync>d__50.MoveNext()
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.<ExecuteAsync>d__9.MoveNext()
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.<ExecuteAsync>d__9.MoveNext()
   at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.<ExecuteAsync>d__9.MoveNext()
   at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.<SaveChangesAsync>d__111.MoveNext()
   at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.<SaveChangesAsync>d__115.MoveNext()
   at Npgsql.EntityFrameworkCore.PostgreSQL.Storage.Internal.NpgsqlExecutionStrategy.<ExecuteAsync>d__7`2.MoveNext()
   at Microsoft.EntityFrameworkCore.DbContext.<SaveChangesAsync>d__63.MoveNext()
   at Microsoft.EntityFrameworkCore.DbContext.<SaveChangesAsync>d__63.MoveNext()
   at 

  This exception was originally thrown at this call stack:
    [External Code]
Inner Exception 1:
InvalidCastException: Writing values of 'NpgsqlTypes.NpgsqlRange`1[[System.TimeSpan, System.Private.CoreLib, Version=8.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]][]' is not supported for parameters having NpgsqlDbType '-2147483608'.
`

[NinoFloris]

@roji this might be related to https://github.com/npgsql/npgsql/pull/5123/files#r1325747341

If so setting the actual datatypename of the range on the param should solve it.

EDIT: traced the regstration to

efcore.pg/src/EFCore.PG/Storage/Internal/NpgsqlTypeMappingSource.cs

Line 883 in 7f6bdbe

var unquotedRangeStoreType = rangeDefinition.SchemaName is null

which suggests that's already happening. Not sure how we end up with a is not supported for parameters having NpgsqlDbType kind of error. That only happens if it was set somehow.

[NinoFloris]

@NazarPolevyi

I notice your entity has the following attribute

  [Column("allowed_time_ranges", TypeName = "timerange[]")]
    public NpgsqlRange<TimeSpan>? AllowedTimeRanges { get; set; }

Specifically timerange[] while the clr type is not an array/list. Can you remove [] and try again?

[NazarPolevyi]

@NinoFloris
Thanks for answer.
@roji What do you think?

I'm sorry. The issue is actually related to array of ranges NpgSqlRange<TimeSpan>[]. So the entity class should look like this.

public class RestrictionSettings
{
    [Column("id")]
    public Guid Id { get; set; }

    [Column("allowed_time_ranges", TypeName = "timerange[]")]
    public NpgsqlRange<TimeSpan>[]? AllowedTimeRanges { get; set; }
}

Usual NpgSqlRange<TimeSpan> works fine.

public class RestrictionSettings
{
    [Column("id")]
    public Guid Id { get; set; }

    [Column("allowed_time_ranges", TypeName = "timerange")]
    public NpgsqlRange<TimeSpan> AllowedTimeRanges { get; set; }
}

Is it possible to use array(NpgsqlRange[]) now in 8.02 version?
Btw, NpgsqlRange<DateTime>[] works well without specifying custom range type. But for the NpgsqlRange<TimeSpan>[] it's not

[roji]

@NinoFloris going over some untriaged issues - am assigning to you as you've already looked into it and there's a good chance this is an Npgsql-level problem.

EF minimal repro

await using var context = new BlogContext();
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();

await using (var connection = await BlogContext.DataSource.OpenConnectionAsync())
{
    await connection.ReloadTypesAsync();
}

context.Blogs.Add(
    new()
    {
        AllowedTimeRanges =
        [
            new(TimeSpan.FromHours(1), TimeSpan.FromHours(2)),
            new(TimeSpan.FromHours(4), TimeSpan.FromHours(6))
        ]
    });
await context.SaveChangesAsync();

public class BlogContext : DbContext
{
    public static readonly NpgsqlDataSource DataSource;

    static BlogContext()
    {
        var dataSourceBuilder = new NpgsqlDataSourceBuilder("Host=localhost;Username=test;Password=test");
        dataSourceBuilder.EnableUnmappedTypes();
        DataSource = dataSourceBuilder.Build();
    }

    public DbSet<Blog> Blogs { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseNpgsql(DataSource, o => o.MapRange<TimeSpan>("timerange", subtypeName: "time without time zone"))
            .LogTo(Console.WriteLine, LogLevel.Information)
            .EnableSensitiveDataLogging();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.HasPostgresRange(name: "timerange", subtype: "time without time zone");
    }}

public class Blog
{
    public int Id { get; set; }

    [Column(TypeName = "timerange[]")]
    public NpgsqlRange<TimeSpan>[] AllowedTimeRanges { get; set; }
}

[NinoFloris]

Quickly ran the repro in the Npgsql project, EF Pg ends up setting NpgsqlDbType.Array | NpgsqlDbType.Unknown onto the parameter's NpgsqlDbType somewhere, though it also sets timerange[] as the datatype name.

As NpgsqlDbType takes precedence we don't know what NpgsqlDbType.Array | NpgsqlDbType.Unknown resolves to. Notably in PG unknown also cannot be composed (unknown[] is an error) so it's also not something we should even want to support.

I expect that when we stop setting NpgsqlDbType this way the issue will be resolved.

This with some composition of the array mapping will cause it:

efcore.pg/src/EFCore.PG/Storage/Internal/Mapping/NpgsqlRangeTypeMapping.cs

Lines 70 to 78 in e4375aa

	public static NpgsqlRangeTypeMapping CreatUserDefinedRangeMapping(
	string quotedRangeStoreType,
	string unquotedRangeStoreType,
	Type rangeClrType,
	RelationalTypeMapping subtypeMapping)
	=> new(quotedRangeStoreType, rangeClrType, rangeNpgsqlDbType: NpgsqlDbType.Unknown, subtypeMapping)
	{
	UnquotedStoreType = unquotedRangeStoreType
	};

[roji]

Quickly ran the repro in the Npgsql project, EF Pg ends up setting NpgsqlDbType.Array | NpgsqlDbType.Unknown onto the parameter's NpgsqlDbType somewhere, though it also sets timerange[] as the datatype name.

EF sets both NpgsqlDbType and DataTypeName? Weird...

[roji]

Thanks for looking @NinoFloris, yeah, this was a result of some complexity around using NpgsqlDbType vs. DataTypeName in addition to arrays. The whole area probably needs a bit of cleanup at some point, but submitted #3342 in the meantime as a targeted fix.