Respect NOT NULL constraints on domain types in arrays.

Brar · roji · commit d4d82a008c99 · 2019-11-03T20:13:01.000+01:00
Return non-nullable arrays from NpgsqlDataReader.GetValue() for arrays
of a domain with a NOT NULL constraint.
diff --git a/src/Npgsql/PostgresDatabaseInfo.cs b/src/Npgsql/PostgresDatabaseInfo.cs
@@ -113,7 +113,7 @@ internal async Task LoadPostgresInfo(NpgsqlConnection conn, NpgsqlTimeout timeou
         static string GenerateTypesQuery(bool withRange, bool withEnum, bool withEnumSortOrder, bool loadTableComposites, bool withTypeCategory)
             => $@"
 /*** Load all supported types ***/
-SELECT ns.nspname, a.typname, a.oid, a.typbasetype,
+SELECT ns.nspname, a.typname, a.oid, a.typbasetype, a.typnotnull,
 CASE WHEN pg_proc.proname='array_recv' THEN 'a' ELSE a.typtype END AS typtype,
 CASE
   WHEN pg_proc.proname='array_recv' THEN a.typelem
@@ -264,7 +264,7 @@ internal async Task<List<PostgresType>> LoadBackendTypes(NpgsqlConnection conn,
                             Log.Trace($"Domain type '{internalName}' refers to unknown base type with OID {baseTypeOID}, skipping", conn.ProcessID);
                             continue;
                         }
-                        var domainType = new PostgresDomainType(ns, internalName, oid, basePostgresType);
+                        var domainType = new PostgresDomainType(ns, internalName, oid, basePostgresType, reader.GetString("typnotnull") == "t");
                         byOID[domainType.OID] = domainType;
                         continue;
 
diff --git a/src/Npgsql/PostgresTypes/PostgresDomainType.cs b/src/Npgsql/PostgresTypes/PostgresDomainType.cs
@@ -21,13 +21,20 @@ public class PostgresDomainType : PostgresType
         [PublicAPI]
         public PostgresType BaseType { get; }
 
+        /// <summary>
+        /// <b>True</b> if the domain has a NOT NULL constraint, otherwise <b>false</b>.
+        /// </summary>
+        [PublicAPI]
+        public bool NotNull { get; }
+
         /// <summary>
         /// Constructs a representation of a PostgreSQL domain data type.
         /// </summary>
-        protected internal PostgresDomainType(string ns, string name, uint oid, PostgresType baseType)
+        protected internal PostgresDomainType(string ns, string name, uint oid, PostgresType baseType, bool notNull)
             : base(ns, name, oid)
         {
             BaseType = baseType;
+            NotNull = notNull;
         }
 
         internal override PostgresFacets GetFacets(int typeModifier)
diff --git a/src/Npgsql/TypeHandlers/ArrayHandler.cs b/src/Npgsql/TypeHandlers/ArrayHandler.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Npgsql.BackendMessages;
 using Npgsql.PostgresTypes;
@@ -279,15 +280,22 @@ public ArrayHandler(PostgresType arrayPostgresType, NpgsqlTypeHandler elementHan
         #region Read
 
         internal override async ValueTask<object> ReadAsObject(NpgsqlReadBuffer buf, int len, bool async, FieldDescription? fieldDescription = null)
-            => typeof(TElement).IsValueType
+            => ReadAsNullable(fieldDescription)
                 ? await ElementTypeInfo<TElement>.ReadNullableArrayFunc(this, buf, async)
                 : await ReadArray<TElement>(buf, async);
 
         internal override object ReadAsObject(NpgsqlReadBuffer buf, int len, FieldDescription? fieldDescription = null)
-            => typeof(TElement).IsValueType
+            => ReadAsNullable(fieldDescription)
                 ? ElementTypeInfo<TElement>.ReadNullableArrayFunc(this, buf, false).GetAwaiter().GetResult()
                 : ReadArray<TElement>(buf, false).GetAwaiter().GetResult();
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] 
+        static bool ReadAsNullable(FieldDescription? fieldDescription)
+            => typeof(TElement).IsValueType &&
+               !(fieldDescription?.PostgresType is PostgresArrayType arrayType &&
+                 arrayType.Element is PostgresDomainType domainType &&
+                 domainType.NotNull);
+
         #endregion
 
         #region Write
diff --git a/test/Npgsql.Tests/Types/ArrayTests.cs b/test/Npgsql.Tests/Types/ArrayTests.cs
@@ -132,7 +132,7 @@ public void EmptyArray()
         }
 
         [Test, Description("Verifies that the array type returned from NpgsqlDataReader.GetValue() is always compatible with null values.")]
-        public void GetValueArrayTypeForValueTypesDependsOnActualValue()
+        public void GetValueArrayTypeForValueTypesIsNullable()
         {
             using (var conn = OpenConnection())
             using (var cmd = new NpgsqlCommand(@"
@@ -157,6 +157,25 @@ INSERT into GetValueArrayTypeForValueTypesDependsOnActualValue VALUES
             }
         }
 
+        [Test, Description("Verifies that the array type returned from NpgsqlDataReader.GetValue() handles NOT NULL constraints on domains correctly.")]
+        public void GetValueRespectsNotNullConstraintsOnDomainsInArrays()
+        {
+            using var conn = OpenConnection();
+            conn.ExecuteNonQuery("CREATE DOMAIN pg_temp.int_not_null AS integer NOT NULL;");
+            conn.ExecuteNonQuery("CREATE DOMAIN pg_temp.int_null AS integer;");
+            conn.ReloadTypes();
+
+            using var cmd = new NpgsqlCommand(@"SELECT '{1,2,3,4}'::pg_temp.int_not_null[], '{1,2,3,4}'::pg_temp.int_null[];", conn);
+            var reader = cmd.ExecuteReader();
+            reader.Read();
+            Assert.That(reader.GetFieldType(0), Is.EqualTo(typeof(Array)));
+            Assert.That(reader.GetValue(0), Is.TypeOf<int[]>());
+            Assert.That(reader.GetFieldValue<int?[]>(0), Is.TypeOf<int?[]>());
+
+            Assert.That(reader.GetFieldType(1), Is.EqualTo(typeof(Array)));
+            Assert.That(reader.GetValue(1), Is.TypeOf<int?[]>());
+            Assert.That(reader.GetFieldValue<int[]>(1), Is.TypeOf<int[]>());
+        }
 
         [Test, Description("Verifies that an attempt to read an Array of value types that contains null values as array of a non-nullable type fails.")]
         public void GetFieldValueNonNullableValueTypeArrayFailsOnArrayContainingNull()
