Fix empty arrays decoding as List<Object?> instead of a list of their element type (#472)

Author: xvrh

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 3.5.19
+
+- Fix empty arrays decoding as `List<Object?>` instead of a list of their element type (a 3.5.18 regression).
+
 ## 3.5.18
 
 - Fix the statement after a failed one sometimes returning no rows.

lib/src/types/binary_codec.dart

@@ -1193,16 +1193,17 @@ class PostgresBinaryDecoder {
     Uint8List data,
     V Function(ByteDataReader reader, int length) valueDecoder,
   ) {
+    // An empty array keeps its element type, as a non-empty one does.
     if (data.length < 12) {
-      return (items: <Object?>[], sqlNulls: <bool>[]);
+      return (items: <V>[], sqlNulls: <bool>[]);
     }
 
     final reader = ByteDataReader()..add(data);
     final ndim = reader.readInt32();
     reader.read(8); // flags (has-null) + element type oid
 
     if (ndim <= 0) {
-      return (items: <Object?>[], sqlNulls: <bool>[]);
+      return (items: <V>[], sqlNulls: <bool>[]);
     }
 
     // One (size, lower bound) pair per dimension; the lower bound has no

pubspec.yaml

@@ -1,6 +1,6 @@
 name: postgres
 description: PostgreSQL database driver. Supports binary protocol, connection pooling and statement reuse.
-version: 3.5.18
+version: 3.5.19
 homepage: https://github.com/isoos/postgresql-dart
 topics:
   - sql

test/encoding_test.dart

@@ -445,6 +445,17 @@ void main() {
       );
     });
 
+    test('an empty array decodes as a list of its element type, as a '
+        'non-empty one does', () async {
+      final row = (await conn.execute(
+        "SELECT '{}'::text[], '{a}'::text[], '{}'::int4[], '{}'::bool[]",
+      )).single;
+      expect(row[0], isA<List<String>>());
+      expect(row[1], isA<List<String>>());
+      expect(row[2], isA<List<int>>());
+      expect(row[3], isA<List<bool>>());
+    });
+
     test('textArray', () async {
       await expectReversible(
         '_text',
@@ -1292,6 +1303,26 @@ void main() {
       expect(result, <int>[]);
     });
 
+    for (final (typeOid, elementOid, matcher) in [
+      (TypeOid.integerArray, TypeOid.integer, isA<List<int>>()),
+      (TypeOid.bigIntegerArray, TypeOid.bigInteger, isA<List<int>>()),
+      (TypeOid.textArray, TypeOid.text, isA<List<String>>()),
+      (TypeOid.varCharArray, TypeOid.varChar, isA<List<String>>()),
+      (TypeOid.booleanArray, TypeOid.boolean, isA<List<bool>>()),
+      (TypeOid.doubleArray, TypeOid.double, isA<List<double>>()),
+      (TypeOid.uuidArray, TypeOid.uuid, isA<List<String>>()),
+    ]) {
+      test('An empty array (oid $typeOid) keeps its element type, so a cast '
+          'that holds for a non-empty one holds for it too', () {
+        final context = CodecContext.withDefaults();
+        // Postgres's wire format for an empty array: ndim=0, flags=0,
+        // elemtype, and no dimensions.
+        final bytes = concatInt32s([0, 0, elementOid]);
+        final result = PostgresBinaryDecoder.convert(context, typeOid, bytes);
+        expect(result, matcher);
+      });
+    }
+
     Uint8List int64Bytes(int value) =>
         (ByteData(8)..setInt64(0, value)).buffer.asUint8List();
     Uint8List int32Bytes(int value) =>