Add test for non-global order writes

Author: kounelisagis

tiledb/tests/test_query.py

@@ -150,3 +150,78 @@ def test_global_order_write_multiple_submits(self, sparse):
                 result = A[1:20]
                 expected_data = np.arange(100, 120, dtype=np.int64)
                 np.testing.assert_array_equal(result["a1"], expected_data[:-1])
+
+    @pytest.mark.parametrize(
+        "sparse,order",
+        [
+            (True, "U"),  # Sparse arrays support unordered
+            (False, "C"),  # Dense arrays support row-major
+            (False, "F"),  # Dense arrays support col-major
+        ],
+    )
+    def test_non_global_order_writes(self, sparse, order):
+        """Test writing in non-global-order modes where each submit creates a new fragment.
+
+        For row-major (C), col-major (F), and unordered (U) modes, finalize is not needed.
+        Each submit creates a separate fragment - incremental writes are not possible.
+
+        Note: C/F (row/col-major) only work for dense arrays, U (unordered) only for sparse.
+        """
+        uri = self.path(
+            f"test_{order}_order_multiple_{'sparse' if sparse else 'dense'}"
+        )
+
+        # Create schema
+        dim = tiledb.Dim("d1", domain=(1, 100), tile=10, dtype=np.int32)
+        dom = tiledb.Domain(dim)
+        att = tiledb.Attr("a1", dtype=np.int64)
+        schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=sparse)
+        tiledb.Array.create(uri, schema)
+
+        # Write using Query with multiple submits (each creates a fragment)
+        with tiledb.open(uri, "w") as A:
+            if sparse:
+                # First submit
+                q1 = tiledb.Query(A, order=order)
+                coords_batch1 = np.array([1, 5, 10], dtype=np.int32)
+                data_batch1 = np.array([100, 200, 300], dtype=np.int64)
+                q1.set_data({"d1": coords_batch1, "a1": data_batch1})
+                q1.submit()
+
+                # Second submit - creates a new fragment
+                q2 = tiledb.Query(A, order=order)
+                coords_batch2 = np.array([15, 20], dtype=np.int32)
+                data_batch2 = np.array([400, 500], dtype=np.int64)
+                q2.set_data({"d1": coords_batch2, "a1": data_batch2})
+                q2.submit()
+            else:
+                # First submit
+                q1 = tiledb.Query(A, order=order)
+                q1.set_subarray_ranges([(1, 10)])
+                data_batch1 = np.arange(100, 110, dtype=np.int64)
+                q1.set_data({"a1": data_batch1})
+                q1.submit()
+
+                # Second submit - creates a new fragment
+                q2 = tiledb.Query(A, order=order)
+                q2.set_subarray_ranges([(11, 20)])
+                data_batch2 = np.arange(110, 120, dtype=np.int64)
+                q2.set_data({"a1": data_batch2})
+                q2.submit()
+
+        # Verify two fragments were created (one per submit)
+        fragments_info = tiledb.array_fragments(uri)
+        assert len(fragments_info) == 2
+
+        # Verify data
+        with tiledb.open(uri, "r") as A:
+            if sparse:
+                result = A[:]
+                expected_data = np.array([100, 200, 300, 400, 500], dtype=np.int64)
+                expected_coords = np.array([1, 5, 10, 15, 20], dtype=np.int32)
+                np.testing.assert_array_equal(result["a1"], expected_data)
+                np.testing.assert_array_equal(result["d1"], expected_coords)
+            else:
+                result = A[1:20]
+                expected_data = np.arange(100, 120, dtype=np.int64)
+                np.testing.assert_array_equal(result["a1"], expected_data[:-1])