fix: for merging when array/struct chunks contain null (#1541)

* fix: for merging when array/struct chunks contain null

* fix: fix for new @types/node version (#1542)

* fix: fix for new @types/node version

* 🦉 Updates from OwlBot

See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md

Co-authored-by: Owl Bot <gcf-owl-bot[bot]@users.noreply.github.com>

* chore(main): release 5.16.2 (#1543)

Co-authored-by: release-please[bot] <55107282+release-please[bot]@users.noreply.github.com>

* fix: adding test case for chunked struct with a null array

Co-authored-by: Owl Bot <gcf-owl-bot[bot]@users.noreply.github.com>
Co-authored-by: release-please[bot] <55107282+release-please[bot]@users.noreply.github.com>

Author: 3 people

src/partial-result-stream.ts

@@ -368,6 +368,9 @@ export class PartialResultStream extends Transform implements ResultEvents {
       type.code === google.spanner.v1.TypeCode.STRUCT ||
       type.code === 'STRUCT'
     ) {
+      if (head === null || tail === null) {
+        return [head, tail];
+      }
       return [PartialResultStream.mergeLists(type, head, tail)];
     }
 

test/data/streaming-read-acceptance-test.json

@@ -332,6 +332,32 @@
         "{\n  \"values\": [\"f\"]\n}"
       ],
       "name": "Multiple Row Chunks/Non Chunks Interleaved"
+    },
+    {
+      "result": {
+        "value": [
+          [
+            [
+              [
+                [
+                  [
+                    "abc"
+                  ],
+                  null,
+                  [
+                    "def"
+                  ]
+                ]
+              ]
+            ]
+          ]
+        ]
+      },
+      "chunks": [
+        "{\n  \"metadata\": {\n    \"rowType\": {\n      \"fields\": [{\n        \"name\": \"f1\",\n        \"type\": {\n          \"code\": \"ARRAY\",\n          \"arrayElementType\": {\n            \"code\": \"STRUCT\",\n            \"structType\": {\n              \"fields\": [{\n                \"name\": \"f11\",\n                \"type\": {\n                  \"code\": \"ARRAY\",\n                  \"arrayElementType\": {\n                    \"code\": \"STRUCT\",\n                    \"structType\": {\n                      \"fields\": [{\n                        \"name\": \"f12\",\n                        \"type\": {\n                          \"code\": \"STRING\"\n                        }\n                      }]\n                    }\n                  }\n                }\n              }]\n            }\n          }\n        }\n      }]\n    }\n  },\n  \"values\": [[[[[\"abc\"], null]]]],\n  \"chunkedValue\": true\n}",
+        "{\n  \"values\": [[[[[\"def\"]]]]]\n}"
+      ],
+      "name": "Nested Struct Array Chunking Test With null"
     }
   ]
 }

test/spanner.ts

@@ -54,6 +54,8 @@ import RequestOptions = google.spanner.v1.RequestOptions;
 import PartialResultSet = google.spanner.v1.PartialResultSet;
 import protobuf = google.spanner.v1;
 import Priority = google.spanner.v1.RequestOptions.Priority;
+import TypeCode = google.spanner.v1.TypeCode;
+import NullValue = google.protobuf.NullValue;
 
 function numberToEnglishWord(num: number): string {
   switch (num) {
@@ -3389,6 +3391,118 @@ describe('Spanner with mock server', () => {
       }
     });
 
+    it('should return all values from PartialResultSet with chunked struct with a null array field', async () => {
+      const sql = 'SELECT * FROM TestTable';
+      const prs1 = PartialResultSet.create({
+        metadata: createArrayOfStructMetadata(),
+        values: [
+          {
+            listValue: {
+              values: [
+                {
+                  listValue: {
+                    values: [
+                      // The array field is NULL.
+                      {nullValue: NullValue.NULL_VALUE},
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+        // This PartialResultSet is chunked, and the last value was the NULL value for the ARRAY field.
+        // This means that the next value will be the STRING field.
+        chunkedValue: true,
+      });
+      const prs2 = PartialResultSet.create({
+        values: [
+          {
+            listValue: {
+              values: [
+                {
+                  listValue: {
+                    values: [{stringValue: 'First row'}],
+                  },
+                },
+              ],
+            },
+          },
+          {
+            listValue: {
+              values: [
+                {
+                  listValue: {
+                    values: [
+                      {listValue: {values: [{stringValue: '1'}]}},
+                      {stringValue: 'Second row'},
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      });
+      setupResultsAndErrors(sql, [prs1, prs2], []);
+      const database = newTestDatabase();
+      try {
+        const [rows] = (await database.run({
+          sql,
+          json: true,
+        })) as Json[];
+        assert.strictEqual(rows.length, 2);
+        assert.strictEqual(rows[0].outerArray.length, 1);
+        assert.strictEqual(rows[0].outerArray[0].innerField, 'First row');
+        assert.ok(
+          rows[0].outerArray[0].innerArray === null,
+          'Inner array should be null'
+        );
+        assert.strictEqual(rows[1].outerArray.length, 1);
+        assert.strictEqual(rows[1].outerArray[0].innerField, 'Second row');
+        assert.strictEqual(rows[1].outerArray[0].innerArray.length, 1);
+        assert.strictEqual(rows[1].outerArray[0].innerArray[0], '1');
+      } finally {
+        await database.close();
+      }
+    });
+
+    function createArrayOfStructMetadata() {
+      const fields = [
+        protobuf.StructType.Field.create({
+          name: 'outerArray',
+          type: protobuf.Type.create({
+            code: protobuf.TypeCode.ARRAY,
+            arrayElementType: protobuf.Type.create({
+              code: protobuf.TypeCode.STRUCT,
+              structType: protobuf.StructType.create({
+                fields: [
+                  {
+                    name: 'innerArray',
+                    type: protobuf.Type.create({
+                      code: TypeCode.ARRAY,
+                      arrayElementType: protobuf.Type.create({
+                        code: TypeCode.STRING,
+                      }),
+                    }),
+                  },
+                  {
+                    name: 'innerField',
+                    type: protobuf.Type.create({code: TypeCode.STRING}),
+                  },
+                ],
+              }),
+            }),
+          }),
+        }),
+      ];
+      return new protobuf.ResultSetMetadata({
+        rowType: new protobuf.StructType({
+          fields,
+        }),
+      });
+    }
+
     it('should reset to the chunked value of the last PartialResultSet with a resume token on retry', async () => {
       // This tests the following scenario:
       // 1. PartialResultSet without resume token, no chunked value.