WIP - needs verification

tiledb/tests/fixtures.py

@@ -8,7 +8,7 @@
 INTEGER_DTYPES = ["u1", "u2", "u4", "u8", "i1", "i2", "i4", "i8"]
 
 
-@pytest.fixture(scope="module", params=["hilbert", "row-major"])
+@pytest.fixture(scope="module", params=["hilbert", "row-major", "col-major"])
 def sparse_cell_order(request):
     yield request.param
 

tiledb/tests/test_libtiledb.py

@@ -2705,17 +2705,18 @@ def test_sparse_mixed_domain_uint_float64(self, sparse_cell_order):
         "coords, expected_ned, allows_duplicates",
         [
             ([b"aa", b"bbb", b"c", b"dddd"], [b"aa", b"dddd"], False),
+            ([b""], [b"", b""], True),
             ([b"", b"", b"", b""], [b"", b""], True),
         ],
     )
     def test_sparse_string_domain(
         self, coords, expected_ned, allows_duplicates, sparse_cell_order
     ):
-        if sparse_cell_order in ("hilbert", "row-major") and allows_duplicates == True:
-            if tiledb.libtiledb.version() < (2, 8):
-                pytest.xfail(
-                    "Skipping known bug with legacy reader and hilbert or row-major layout"
-                )
+        # if sparse_cell_order in ("hilbert", "row-major", "col-major") and allows_duplicates == True:
+        #    if tiledb.libtiledb.version() < (2, 8):
+        #        pytest.xfail(
+        #            "Skipping known bug with legacy reader and empty strings"
+        #        )
 
         path = self.path("sparse_string_domain")
         dom = tiledb.Domain(tiledb.Dim(name="d", domain=(None, None), dtype=np.bytes_))
@@ -2730,19 +2731,32 @@ def test_sparse_string_domain(
         )
         tiledb.SparseArray.create(path, schema)
 
-        data = [1, 2, 3, 4]
+        data = [1, 2, 3, 4][: len(coords)]
 
         with tiledb.open(path, "w") as A:
+            breakpoint()
             A[coords] = data
 
         with tiledb.open(path) as A:
             ned = A.nonempty_domain()[0]
-            res = A[ned[0] : ned[1]]
-            assert_array_equal(res["a"], data)
-            self.assertEqual(set(res["d"]), set(coords))
-            # self.assertEqual(A.nonempty_domain(), ((b"aa", b"dddd"),))
             self.assertEqual(A.nonempty_domain(), ((tuple(expected_ned)),))
 
+            if not (
+                sparse_cell_order in ("hilbert", "row-major", "col-major")
+                and allows_duplicates == True
+            ):
+                assert_array_equal(A[ned[0] : ned[1]]["a"], data)
+                self.assertEqual(set(A[ned[0] : ned[1]]["d"]), set(coords))
+
+            if allows_duplicates and sparse_cell_order != "hilbert":
+                res_u1 = A.query(order="U").multi_index[ned[0] : ned[1]]
+                assert_array_equal(res_u1["a"], data)
+                self.assertEqual(set(res_u1["d"]), set(coords))
+
+                res_u2 = A.query(order="U")[ned[0] : ned[1]]
+                assert_array_equal(res_u2["a"], data)
+                self.assertEqual(set(res_u2["d"]), set(coords))
+
     def test_sparse_string_domain2(self, sparse_cell_order):
         path = self.path("sparse_string_domain2")
         with self.assertRaises(ValueError):