Map date/time to DateOnly/TimeOnly by default (npgsql#5948)

roji · web-flow · commit d606795781c4 · 2024-11-20T18:20:03.000+02:00
Closes npgsql#5328
diff --git a/src/Npgsql/Internal/Converters/Temporal/DateConverters.cs b/src/Npgsql/Internal/Converters/Temporal/DateConverters.cs
@@ -4,88 +4,88 @@
 // ReSharper disable once CheckNamespace
 namespace Npgsql.Internal.Converters;
 
-sealed class DateTimeDateConverter(bool dateTimeInfinityConversions) : PgBufferedConverter<DateTime>
+sealed class DateOnlyDateConverter(bool dateTimeInfinityConversions) : PgBufferedConverter<DateOnly>
 {
-    static readonly DateTime BaseValue = new(2000, 1, 1, 0, 0, 0);
+    static readonly DateOnly BaseValue = new(2000, 1, 1);
 
     public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)
     {
         bufferRequirements = BufferRequirements.CreateFixedSize(sizeof(int));
         return format is DataFormat.Binary;
     }
 
-    protected override DateTime ReadCore(PgReader reader)
+    protected override DateOnly ReadCore(PgReader reader)
         => reader.ReadInt32() switch
         {
             int.MaxValue => dateTimeInfinityConversions
-                ? DateTime.MaxValue
+                ? DateOnly.MaxValue
                 : throw new InvalidCastException(NpgsqlStrings.CannotReadInfinityValue),
             int.MinValue => dateTimeInfinityConversions
-                ? DateTime.MinValue
+                ? DateOnly.MinValue
                 : throw new InvalidCastException(NpgsqlStrings.CannotReadInfinityValue),
-            var value => BaseValue + TimeSpan.FromDays(value)
+            var value => BaseValue.AddDays(value)
         };
 
-    protected override void WriteCore(PgWriter writer, DateTime value)
+    protected override void WriteCore(PgWriter writer, DateOnly value)
     {
         if (dateTimeInfinityConversions)
         {
-            if (value == DateTime.MaxValue)
+            if (value == DateOnly.MaxValue)
             {
                 writer.WriteInt32(int.MaxValue);
                 return;
             }
 
-            if (value == DateTime.MinValue)
+            if (value == DateOnly.MinValue)
             {
                 writer.WriteInt32(int.MinValue);
                 return;
             }
         }
 
-        writer.WriteInt32((value.Date - BaseValue).Days);
+        writer.WriteInt32(value.DayNumber - BaseValue.DayNumber);
     }
 }
 
-sealed class DateOnlyDateConverter(bool dateTimeInfinityConversions) : PgBufferedConverter<DateOnly>
+sealed class DateTimeDateConverter(bool dateTimeInfinityConversions) : PgBufferedConverter<DateTime>
 {
-    static readonly DateOnly BaseValue = new(2000, 1, 1);
+    static readonly DateTime BaseValue = new(2000, 1, 1, 0, 0, 0);
 
     public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)
     {
         bufferRequirements = BufferRequirements.CreateFixedSize(sizeof(int));
         return format is DataFormat.Binary;
     }
 
-    protected override DateOnly ReadCore(PgReader reader)
+    protected override DateTime ReadCore(PgReader reader)
         => reader.ReadInt32() switch
         {
             int.MaxValue => dateTimeInfinityConversions
-                ? DateOnly.MaxValue
+                ? DateTime.MaxValue
                 : throw new InvalidCastException(NpgsqlStrings.CannotReadInfinityValue),
             int.MinValue => dateTimeInfinityConversions
-                ? DateOnly.MinValue
+                ? DateTime.MinValue
                 : throw new InvalidCastException(NpgsqlStrings.CannotReadInfinityValue),
-            var value => BaseValue.AddDays(value)
+            var value => BaseValue + TimeSpan.FromDays(value)
         };
 
-    protected override void WriteCore(PgWriter writer, DateOnly value)
+    protected override void WriteCore(PgWriter writer, DateTime value)
     {
         if (dateTimeInfinityConversions)
         {
-            if (value == DateOnly.MaxValue)
+            if (value == DateTime.MaxValue)
             {
                 writer.WriteInt32(int.MaxValue);
                 return;
             }
 
-            if (value == DateOnly.MinValue)
+            if (value == DateTime.MinValue)
             {
                 writer.WriteInt32(int.MinValue);
                 return;
             }
         }
 
-        writer.WriteInt32(value.DayNumber - BaseValue.DayNumber);
+        writer.WriteInt32((value.Date - BaseValue).Days);
     }
 }
diff --git a/src/Npgsql/Internal/Converters/Temporal/TimeConverters.cs b/src/Npgsql/Internal/Converters/Temporal/TimeConverters.cs
@@ -3,26 +3,26 @@
 // ReSharper disable once CheckNamespace
 namespace Npgsql.Internal.Converters;
 
-sealed class TimeSpanTimeConverter : PgBufferedConverter<TimeSpan>
+sealed class TimeOnlyTimeConverter : PgBufferedConverter<TimeOnly>
 {
     public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)
     {
         bufferRequirements = BufferRequirements.CreateFixedSize(sizeof(long));
         return format is DataFormat.Binary;
     }
-    protected override TimeSpan ReadCore(PgReader reader) => new(reader.ReadInt64() * 10);
-    protected override void WriteCore(PgWriter writer, TimeSpan value) => writer.WriteInt64(value.Ticks / 10);
+    protected override TimeOnly ReadCore(PgReader reader) => new(reader.ReadInt64() * 10);
+    protected override void WriteCore(PgWriter writer, TimeOnly value) => writer.WriteInt64(value.Ticks / 10);
 }
 
-sealed class TimeOnlyTimeConverter : PgBufferedConverter<TimeOnly>
+sealed class TimeSpanTimeConverter : PgBufferedConverter<TimeSpan>
 {
     public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)
     {
         bufferRequirements = BufferRequirements.CreateFixedSize(sizeof(long));
         return format is DataFormat.Binary;
     }
-    protected override TimeOnly ReadCore(PgReader reader) => new(reader.ReadInt64() * 10);
-    protected override void WriteCore(PgWriter writer, TimeOnly value) => writer.WriteInt64(value.Ticks / 10);
+    protected override TimeSpan ReadCore(PgReader reader) => new(reader.ReadInt64() * 10);
+    protected override void WriteCore(PgWriter writer, TimeSpan value) => writer.WriteInt64(value.Ticks / 10);
 }
 
 sealed class DateTimeOffsetTimeTzConverter : PgBufferedConverter<DateTimeOffset>
diff --git a/src/Npgsql/Internal/ResolverFactories/AdoTypeInfoResolverFactory.Multirange.cs b/src/Npgsql/Internal/ResolverFactories/AdoTypeInfoResolverFactory.Multirange.cs
@@ -159,24 +159,23 @@ static TypeInfoMappingCollection AddMappings(TypeInfoMappingCollection mappings)
                         CreateListMultirangeConverter(CreateRangeConverter(new Int8Converter<long>(), options), options)));
 
             // datemultirange
-            mappings.AddType<NpgsqlRange<DateTime>[]>(DataTypeNames.DateMultirange,
-                static (options, mapping, _) =>
-                    mapping.CreateInfo(options, CreateArrayMultirangeConverter(
-                        CreateRangeConverter(new DateTimeDateConverter(options.EnableDateTimeInfinityConversions), options), options)),
-                isDefault: true);
-            mappings.AddType<List<NpgsqlRange<DateTime>>>(DataTypeNames.DateMultirange,
-                static (options, mapping, _) =>
-                    mapping.CreateInfo(options, CreateListMultirangeConverter(
-                        CreateRangeConverter(new DateTimeDateConverter(options.EnableDateTimeInfinityConversions), options), options)));
             mappings.AddType<NpgsqlRange<DateOnly>[]>(DataTypeNames.DateMultirange,
                 static (options, mapping, _) =>
                     mapping.CreateInfo(options, CreateArrayMultirangeConverter(
                         CreateRangeConverter(new DateOnlyDateConverter(options.EnableDateTimeInfinityConversions), options), options)),
                 isDefault: true);
+            mappings.AddType<NpgsqlRange<DateTime>[]>(DataTypeNames.DateMultirange,
+                static (options, mapping, _) =>
+                    mapping.CreateInfo(options, CreateArrayMultirangeConverter(
+                        CreateRangeConverter(new DateTimeDateConverter(options.EnableDateTimeInfinityConversions), options), options)));
             mappings.AddType<List<NpgsqlRange<DateOnly>>>(DataTypeNames.DateMultirange,
                 static (options, mapping, _) =>
                     mapping.CreateInfo(options, CreateListMultirangeConverter(
                         CreateRangeConverter(new DateOnlyDateConverter(options.EnableDateTimeInfinityConversions), options), options)));
+            mappings.AddType<List<NpgsqlRange<DateTime>>>(DataTypeNames.DateMultirange,
+                static (options, mapping, _) =>
+                    mapping.CreateInfo(options, CreateListMultirangeConverter(
+                        CreateRangeConverter(new DateTimeDateConverter(options.EnableDateTimeInfinityConversions), options), options)));
 
             return mappings;
         }
diff --git a/src/Npgsql/Internal/ResolverFactories/AdoTypeInfoResolverFactory.Range.cs b/src/Npgsql/Internal/ResolverFactories/AdoTypeInfoResolverFactory.Range.cs
@@ -87,15 +87,16 @@ static TypeInfoMappingCollection AddMappings(TypeInfoMappingCollection mappings)
                 static (options, mapping, _) => mapping.CreateInfo(options, CreateRangeConverter(new Int8Converter<long>(), options)));
 
             // daterange
+            mappings.AddStructType<NpgsqlRange<DateOnly>>(DataTypeNames.DateRange,
+                static (options, mapping, _) =>
+                    mapping.CreateInfo(options,
+                        CreateRangeConverter(new DateOnlyDateConverter(options.EnableDateTimeInfinityConversions), options)),
+                isDefault: true);
             mappings.AddStructType<NpgsqlRange<DateTime>>(DataTypeNames.DateRange,
                 static (options, mapping, _) => mapping.CreateInfo(options,
-                    CreateRangeConverter(new DateTimeDateConverter(options.EnableDateTimeInfinityConversions), options)),
-                isDefault: true);
+                    CreateRangeConverter(new DateTimeDateConverter(options.EnableDateTimeInfinityConversions), options)));
             mappings.AddStructType<NpgsqlRange<int>>(DataTypeNames.DateRange,
                 static (options, mapping, _) => mapping.CreateInfo(options, CreateRangeConverter(new Int4Converter<int>(), options)));
-            mappings.AddStructType<NpgsqlRange<DateOnly>>(DataTypeNames.DateRange,
-                static (options, mapping, _) =>
-                    mapping.CreateInfo(options, CreateRangeConverter(new DateOnlyDateConverter(options.EnableDateTimeInfinityConversions), options)));
 
             return mappings;
         }
diff --git a/src/Npgsql/Internal/ResolverFactories/AdoTypeInfoResolverFactory.cs b/src/Npgsql/Internal/ResolverFactories/AdoTypeInfoResolverFactory.cs
@@ -230,14 +230,15 @@ static TypeInfoMappingCollection AddMappings(TypeInfoMappingCollection mappings)
                 static (options, mapping, _) => mapping.CreateInfo(options, new Int8Converter<long>()));
 
             // Date
+            mappings.AddStructType<DateOnly>(DataTypeNames.Date,
+                static (options, mapping, _) =>
+                    mapping.CreateInfo(options, new DateOnlyDateConverter(options.EnableDateTimeInfinityConversions)), isDefault: true);
             mappings.AddStructType<DateTime>(DataTypeNames.Date,
                 static (options, mapping, _) =>
                     mapping.CreateInfo(options, new DateTimeDateConverter(options.EnableDateTimeInfinityConversions)),
                 MatchRequirement.DataTypeName);
             mappings.AddStructType<int>(DataTypeNames.Date,
                 static (options, mapping, _) => mapping.CreateInfo(options, new Int4Converter<int>()));
-            mappings.AddStructType<DateOnly>(DataTypeNames.Date,
-                static (options, mapping, _) => mapping.CreateInfo(options, new DateOnlyDateConverter(options.EnableDateTimeInfinityConversions)));
 
             // Interval
             mappings.AddStructType<TimeSpan>(DataTypeNames.Interval,
@@ -246,12 +247,12 @@ static TypeInfoMappingCollection AddMappings(TypeInfoMappingCollection mappings)
                 static (options, mapping, _) => mapping.CreateInfo(options, new NpgsqlIntervalConverter()));
 
             // Time
+            mappings.AddStructType<TimeOnly>(DataTypeNames.Time,
+                static (options, mapping, _) => mapping.CreateInfo(options, new TimeOnlyTimeConverter()), isDefault: true);
             mappings.AddStructType<TimeSpan>(DataTypeNames.Time,
-                static (options, mapping, _) => mapping.CreateInfo(options, new TimeSpanTimeConverter()), isDefault: true);
+                static (options, mapping, _) => mapping.CreateInfo(options, new TimeSpanTimeConverter()));
             mappings.AddStructType<long>(DataTypeNames.Time,
                 static (options, mapping, _) => mapping.CreateInfo(options, new Int8Converter<long>()));
-            mappings.AddStructType<TimeOnly>(DataTypeNames.Time,
-                static (options, mapping, _) => mapping.CreateInfo(options, new TimeOnlyTimeConverter()));
 
             // TimeTz
             mappings.AddStructType<DateTimeOffset>(DataTypeNames.TimeTz,
@@ -446,9 +447,9 @@ static TypeInfoMappingCollection AddMappings(TypeInfoMappingCollection mappings)
             mappings.AddStructArrayType<long>(DataTypeNames.TimestampTz);
 
             // Date
+            mappings.AddStructArrayType<DateOnly>(DataTypeNames.Date);
             mappings.AddStructArrayType<DateTime>(DataTypeNames.Date);
             mappings.AddStructArrayType<int>(DataTypeNames.Date);
-            mappings.AddStructArrayType<DateOnly>(DataTypeNames.Date);
 
             // Interval
             mappings.AddStructArrayType<TimeSpan>(DataTypeNames.Interval);
diff --git a/test/Npgsql.Tests/CommandBuilderTests.cs b/test/Npgsql.Tests/CommandBuilderTests.cs
@@ -341,7 +341,7 @@ PRIMARY KEY (Cod)
 
         Assert.That(row[0], Is.EqualTo("key1"));
         Assert.That(row[1], Is.EqualTo("description"));
-        Assert.That(row[2], Is.EqualTo(new DateTime(2018, 7, 3)));
+        Assert.That(row[2], Is.EqualTo(new DateOnly(2018, 7, 3)));
         Assert.That(row[3], Is.EqualTo(new DateTime(2018, 7, 3, 7, 2, 0)));
         Assert.That(row[4], Is.EqualTo(123));
         Assert.That(row[5], Is.EqualTo(123.4));
diff --git a/test/Npgsql.Tests/ExceptionTests.cs b/test/Npgsql.Tests/ExceptionTests.cs
@@ -250,6 +250,8 @@ PostgresException CreateWithSqlState(string sqlState)
 
 #pragma warning disable SYSLIB0011
 #pragma warning disable SYSLIB0050
+
+#if !NET9_0_OR_GREATER // BinaryFormatter serialization and deserialization have been removed. See https://aka.ms/binaryformatter for more information.
     [Test]
     public void Serialization()
     {
@@ -283,6 +285,7 @@ public void Serialization()
         Assert.That(expected.Line, Is.EqualTo(actual.Line));
         Assert.That(expected.Routine, Is.EqualTo(actual.Routine));
     }
+#endif
 
     SerializationInfo CreateSerializationInfo() => new(typeof(PostgresException), new FormatterConverter());
 #pragma warning restore SYSLIB0011
diff --git a/test/Npgsql.Tests/ReaderTests.cs b/test/Npgsql.Tests/ReaderTests.cs
@@ -475,7 +475,7 @@ public async Task GetValues()
             dr.Read();
             var values = new object[4];
             Assert.That(dr.GetValues(values), Is.EqualTo(3));
-            Assert.That(values, Is.EqualTo(new object?[] { "hello", 1, new DateTime(2014, 1, 1), null }));
+            Assert.That(values, Is.EqualTo(new object?[] { "hello", 1, new DateOnly(2014, 1, 1), null }));
         }
         using (var dr = await command.ExecuteReaderAsync(Behavior))
         {
diff --git a/test/Npgsql.Tests/Types/DateTimeTests.cs b/test/Npgsql.Tests/Types/DateTimeTests.cs
diff --git a/test/Npgsql.Tests/Types/MultirangeTests.cs b/test/Npgsql.Tests/Types/MultirangeTests.cs

Original file line number	Diff line number	Diff line change
`@@ -4,88 +4,88 @@`
`4`	`4`	`// ReSharper disable once CheckNamespace`
`5`	`5`	`namespace Npgsql.Internal.Converters;`
`6`	`6`
`7`		`-sealed class DateTimeDateConverter(bool dateTimeInfinityConversions) : PgBufferedConverter<DateTime>`
	`7`	`+sealed class DateOnlyDateConverter(bool dateTimeInfinityConversions) : PgBufferedConverter<DateOnly>`
`8`	`8`	`{`
`9`		`- static readonly DateTime BaseValue = new(2000, 1, 1, 0, 0, 0);`
	`9`	`+ static readonly DateOnly BaseValue = new(2000, 1, 1);`
`10`	`10`
`11`	`11`	`public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)`
`12`	`12`	`{`
`13`	`13`	`bufferRequirements = BufferRequirements.CreateFixedSize(sizeof(int));`
`14`	`14`	`return format is DataFormat.Binary;`
`15`	`15`	`}`
`16`	`16`
`17`		`- protected override DateTime ReadCore(PgReader reader)`
	`17`	`+ protected override DateOnly ReadCore(PgReader reader)`
`18`	`18`	`=> reader.ReadInt32() switch`
`19`	`19`	`{`
`20`	`20`	`int.MaxValue => dateTimeInfinityConversions`
`21`		`- ? DateTime.MaxValue`
	`21`	`+ ? DateOnly.MaxValue`
`22`	`22`	`: throw new InvalidCastException(NpgsqlStrings.CannotReadInfinityValue),`
`23`	`23`	`int.MinValue => dateTimeInfinityConversions`
`24`		`- ? DateTime.MinValue`
	`24`	`+ ? DateOnly.MinValue`
`25`	`25`	`: throw new InvalidCastException(NpgsqlStrings.CannotReadInfinityValue),`
`26`		`- var value => BaseValue + TimeSpan.FromDays(value)`
	`26`	`+ var value => BaseValue.AddDays(value)`
`27`	`27`	`};`
`28`	`28`
`29`		`- protected override void WriteCore(PgWriter writer, DateTime value)`
	`29`	`+ protected override void WriteCore(PgWriter writer, DateOnly value)`
`30`	`30`	`{`
`31`	`31`	`if (dateTimeInfinityConversions)`
`32`	`32`	`{`
`33`		`- if (value == DateTime.MaxValue)`
	`33`	`+ if (value == DateOnly.MaxValue)`
`34`	`34`	`{`
`35`	`35`	`writer.WriteInt32(int.MaxValue);`
`36`	`36`	`return;`
`37`	`37`	`}`
`38`	`38`
`39`		`- if (value == DateTime.MinValue)`
	`39`	`+ if (value == DateOnly.MinValue)`
`40`	`40`	`{`
`41`	`41`	`writer.WriteInt32(int.MinValue);`
`42`	`42`	`return;`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`- writer.WriteInt32((value.Date - BaseValue).Days);`
	`46`	`+ writer.WriteInt32(value.DayNumber - BaseValue.DayNumber);`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`-sealed class DateOnlyDateConverter(bool dateTimeInfinityConversions) : PgBufferedConverter<DateOnly>`
	`50`	`+sealed class DateTimeDateConverter(bool dateTimeInfinityConversions) : PgBufferedConverter<DateTime>`
`51`	`51`	`{`
`52`		`- static readonly DateOnly BaseValue = new(2000, 1, 1);`
	`52`	`+ static readonly DateTime BaseValue = new(2000, 1, 1, 0, 0, 0);`
`53`	`53`
`54`	`54`	`public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)`
`55`	`55`	`{`
`56`	`56`	`bufferRequirements = BufferRequirements.CreateFixedSize(sizeof(int));`
`57`	`57`	`return format is DataFormat.Binary;`
`58`	`58`	`}`
`59`	`59`
`60`		`- protected override DateOnly ReadCore(PgReader reader)`
	`60`	`+ protected override DateTime ReadCore(PgReader reader)`
`61`	`61`	`=> reader.ReadInt32() switch`
`62`	`62`	`{`
`63`	`63`	`int.MaxValue => dateTimeInfinityConversions`
`64`		`- ? DateOnly.MaxValue`
	`64`	`+ ? DateTime.MaxValue`
`65`	`65`	`: throw new InvalidCastException(NpgsqlStrings.CannotReadInfinityValue),`
`66`	`66`	`int.MinValue => dateTimeInfinityConversions`
`67`		`- ? DateOnly.MinValue`
	`67`	`+ ? DateTime.MinValue`
`68`	`68`	`: throw new InvalidCastException(NpgsqlStrings.CannotReadInfinityValue),`
`69`		`- var value => BaseValue.AddDays(value)`
	`69`	`+ var value => BaseValue + TimeSpan.FromDays(value)`
`70`	`70`	`};`
`71`	`71`
`72`		`- protected override void WriteCore(PgWriter writer, DateOnly value)`
	`72`	`+ protected override void WriteCore(PgWriter writer, DateTime value)`
`73`	`73`	`{`
`74`	`74`	`if (dateTimeInfinityConversions)`
`75`	`75`	`{`
`76`		`- if (value == DateOnly.MaxValue)`
	`76`	`+ if (value == DateTime.MaxValue)`
`77`	`77`	`{`
`78`	`78`	`writer.WriteInt32(int.MaxValue);`
`79`	`79`	`return;`
`80`	`80`	`}`
`81`	`81`
`82`		`- if (value == DateOnly.MinValue)`
	`82`	`+ if (value == DateTime.MinValue)`
`83`	`83`	`{`
`84`	`84`	`writer.WriteInt32(int.MinValue);`
`85`	`85`	`return;`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`		`- writer.WriteInt32(value.DayNumber - BaseValue.DayNumber);`
	`89`	`+ writer.WriteInt32((value.Date - BaseValue).Days);`
`90`	`90`	`}`
`91`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,26 +3,26 @@`
`3`	`3`	`// ReSharper disable once CheckNamespace`
`4`	`4`	`namespace Npgsql.Internal.Converters;`
`5`	`5`
`6`		`-sealed class TimeSpanTimeConverter : PgBufferedConverter<TimeSpan>`
	`6`	`+sealed class TimeOnlyTimeConverter : PgBufferedConverter<TimeOnly>`
`7`	`7`	`{`
`8`	`8`	`public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)`
`9`	`9`	`{`
`10`	`10`	`bufferRequirements = BufferRequirements.CreateFixedSize(sizeof(long));`
`11`	`11`	`return format is DataFormat.Binary;`
`12`	`12`	`}`
`13`		`- protected override TimeSpan ReadCore(PgReader reader) => new(reader.ReadInt64() * 10);`
`14`		`- protected override void WriteCore(PgWriter writer, TimeSpan value) => writer.WriteInt64(value.Ticks / 10);`
	`13`	`+ protected override TimeOnly ReadCore(PgReader reader) => new(reader.ReadInt64() * 10);`
	`14`	`+ protected override void WriteCore(PgWriter writer, TimeOnly value) => writer.WriteInt64(value.Ticks / 10);`
`15`	`15`	`}`
`16`	`16`
`17`		`-sealed class TimeOnlyTimeConverter : PgBufferedConverter<TimeOnly>`
	`17`	`+sealed class TimeSpanTimeConverter : PgBufferedConverter<TimeSpan>`
`18`	`18`	`{`
`19`	`19`	`public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)`
`20`	`20`	`{`
`21`	`21`	`bufferRequirements = BufferRequirements.CreateFixedSize(sizeof(long));`
`22`	`22`	`return format is DataFormat.Binary;`
`23`	`23`	`}`
`24`		`- protected override TimeOnly ReadCore(PgReader reader) => new(reader.ReadInt64() * 10);`
`25`		`- protected override void WriteCore(PgWriter writer, TimeOnly value) => writer.WriteInt64(value.Ticks / 10);`
	`24`	`+ protected override TimeSpan ReadCore(PgReader reader) => new(reader.ReadInt64() * 10);`
	`25`	`+ protected override void WriteCore(PgWriter writer, TimeSpan value) => writer.WriteInt64(value.Ticks / 10);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`sealed class DateTimeOffsetTimeTzConverter : PgBufferedConverter<DateTimeOffset>`
Original file line number	Diff line number	Diff line change
`@@ -250,6 +250,8 @@ PostgresException CreateWithSqlState(string sqlState)`
`250`	`250`
`251`	`251`	`#pragma warning disable SYSLIB0011`
`252`	`252`	`#pragma warning disable SYSLIB0050`
	`253`	`+`
	`254`	`+#if !NET9_0_OR_GREATER // BinaryFormatter serialization and deserialization have been removed. See https://aka.ms/binaryformatter for more information.`
`253`	`255`	`[Test]`
`254`	`256`	`public void Serialization()`
`255`	`257`	`{`
`@@ -283,6 +285,7 @@ public void Serialization()`
`283`	`285`	`Assert.That(expected.Line, Is.EqualTo(actual.Line));`
`284`	`286`	`Assert.That(expected.Routine, Is.EqualTo(actual.Routine));`
`285`	`287`	`}`
	`288`	`+#endif`
`286`	`289`
`287`	`290`	`SerializationInfo CreateSerializationInfo() => new(typeof(PostgresException), new FormatterConverter());`
`288`	`291`	`#pragma warning restore SYSLIB0011`
Original file line number	Diff line number	Diff line change
`@@ -475,7 +475,7 @@ public async Task GetValues()`
`475`	`475`	`dr.Read();`
`476`	`476`	`var values = new object[4];`
`477`	`477`	`Assert.That(dr.GetValues(values), Is.EqualTo(3));`
`478`		`- Assert.That(values, Is.EqualTo(new object?[] { "hello", 1, new DateTime(2014, 1, 1), null }));`
	`478`	`+ Assert.That(values, Is.EqualTo(new object?[] { "hello", 1, new DateOnly(2014, 1, 1), null }));`
`479`	`479`	`}`
`480`	`480`	`using (var dr = await command.ExecuteReaderAsync(Behavior))`
`481`	`481`	`{`