npgsql · vonzshik · Oct 15, 2025 · Oct 8, 2025
@@ -259,8 +259,11 @@ void ColumnPostConfig(NpgsqlDbColumn column, int typeModifier)
     {
         var serializerOptions = _connection.Connector!.SerializerOptions;
 
-        column.NpgsqlDbType = column.PostgresType.DataTypeName.ToNpgsqlDbType();
-        if (serializerOptions.GetDefaultTypeInfo(serializerOptions.ToCanonicalTypeId(column.PostgresType)) is { } typeInfo)
+        // Call GetRepresentationalType to also handle domain types
+        // Because NpgsqlCommandBuilder relies on NpgsqlDbType for correct type mapping
+        // And otherwise we'll get NpgsqlDbType.Unknown
+        column.NpgsqlDbType = column.PostgresType.GetRepresentationalType().DataTypeName.ToNpgsqlDbType();
+        if (serializerOptions.GetTypeInfo(typeof(object), serializerOptions.ToCanonicalTypeId(column.PostgresType)) is { } typeInfo)
         {
             column.DataType = typeInfo.Type;
             column.IsLong = column.PostgresType.DataTypeName == DataTypeNames.Bytea;

@@ -387,4 +387,60 @@ public async Task Get_update_command_with_array_column_type()
 
         daDataAdapter.Update(dtTable);
     }
+
+    [Test, IssueLink("https://github.com/npgsql/npgsql/issues/6240")]
+    public async Task Get_update_command_with_domain_column_type()
+    {
+        await using var adminConnection = await OpenConnectionAsync();
+        var domainTypeName = await GetTempTypeName(adminConnection);
+
+        await adminConnection.ExecuteNonQueryAsync($"CREATE DOMAIN {domainTypeName} AS smallint");
+
+        var tableName = await CreateTempTable(adminConnection, $"id serial PRIMARY KEY, domtest {domainTypeName}");
+
+        await using var dataSource = CreateDataSource();
+        await using var conn = await dataSource.OpenConnectionAsync();
+
+        using var adapter = new NpgsqlDataAdapter($"select * from {tableName}", conn);
+
+        var builder = new NpgsqlCommandBuilder(adapter)
+        {
+            ConflictOption = ConflictOption.CompareAllSearchableValues,
+            SetAllValues = true
+        };
+
+        adapter.InsertCommand = builder.GetInsertCommand();
+        adapter.UpdateCommand = builder.GetUpdateCommand();
+        adapter.DeleteCommand = builder.GetDeleteCommand();
+
+        using var dataTable = new DataTable();
+
+        adapter.Fill(dataTable);
+
+        const short sval = 5;
+
+        var newRow = dataTable.NewRow();
+        newRow[1] = sval;
+        dataTable.Rows.Add(newRow);
+
+        adapter.Update(dataTable);
+    }
+
+    [Test, IssueLink("https://github.com/npgsql/npgsql/issues/6240")]
+    public async Task Fill_datatable_with_array_column_type()
+    {
+        await using var connection = await OpenConnectionAsync();
+
+        var tableName = await CreateTempTable(connection, "id serial PRIMARY KEY, textarr text[] COLLATE pg_catalog.\"default\"");
+
+        using var adapter = new NpgsqlDataAdapter($"select * from {tableName}", connection);
+
+        using var dataTable = new DataTable();
+
+        adapter.FillSchema(dataTable, SchemaType.Source);
+
+        adapter.MissingSchemaAction = MissingSchemaAction.Ignore;
+
+        adapter.Fill(dataTable);
+    }
 }
@@ -1,4 +1,5 @@
-using System.Collections.ObjectModel;
+using System;
+using System.Collections.ObjectModel;
 using System.Data;
 using System.Data.Common;
 using System.Linq;
@@ -450,6 +451,19 @@ public async Task DataType_with_composite()
         Assert.That(columns[1].UdtAssemblyQualifiedName, Is.EqualTo(typeof(SomeComposite).AssemblyQualifiedName));
     }
 
+    [Test]
+    public async Task DataType_with_array()
+    {
+        using var conn = await OpenConnectionAsync();
+        var table = await CreateTempTable(conn, "foo INTEGER[]");
+
+        using var cmd = new NpgsqlCommand($"SELECT foo, ARRAY[1::INTEGER, 2::INTEGER] FROM {table}", conn);
+        using var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SchemaOnly);
+        var columns = await GetColumnSchema(reader);
+        Assert.That(columns[0].DataType, Is.SameAs(typeof(Array)));
+        Assert.That(columns[1].DataType, Is.SameAs(typeof(Array)));
+    }
+
     [Test]
     public async Task UdtAssemblyQualifiedName()
     {
@@ -673,6 +687,8 @@ public async Task Domain_type()
         var pgType = domainSchema.PostgresType;
         Assert.That(pgType, Is.InstanceOf<PostgresDomainType>());
         Assert.That(((PostgresDomainType)pgType).BaseType.Name, Is.EqualTo("character varying"));
+        // For domains we should return the underlying type
+        Assert.That(domainSchema.NpgsqlDbType, Is.EqualTo(NpgsqlTypes.NpgsqlDbType.Varchar));
     }
 
     [Test]

@@ -304,7 +304,7 @@ public async Task GetFieldType_SchemaOnly()
     {
         await using var conn = await OpenConnectionAsync();
         await using var cmd = new NpgsqlCommand(@"SELECT 1::INT4 AS some_column", conn);
-        await using var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SchemaOnly);
+        await using var reader = await cmd.ExecuteReaderAsync(Behavior | CommandBehavior.SchemaOnly);
         reader.Read();
         Assert.That(reader.GetFieldType(0), Is.SameAs(typeof(int)));
     }