testbed/TileDB-Inc__TileDB-Py/tiledb/tests/test_multi_index.py

"""
TODO
- # implement mock of expected behavior in pure numpy w/ test function


- implement read function and tests (single [x], multi-attribute [ ])
- implement custom indexer
- implement oindex...
"""

import random

import numpy as np
import pytest
from numpy.testing import assert_array_equal

import tiledb
from tiledb.multirange_indexing import getitem_ranges, mr_dense_result_shape

from .common import (
    SUPPORTED_DATETIME64_DTYPES,
    DiskTestCase,
    assert_dict_arrays_equal,
    assert_tail_equal,
    has_pandas,
    has_pyarrow,
    intspace,
    rand_datetime64_array,
)


def make_1d_dense(path, attr_name="", attr_dtype=np.int64, dim_dtype=np.uint64):
    a_orig = np.arange(36)

    dom = tiledb.Domain(tiledb.Dim(domain=(0, 35), tile=35, dtype=dim_dtype))
    att = tiledb.Attr(name=attr_name, dtype=attr_dtype)
    schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=False)
    tiledb.DenseArray.create(path, schema)

    with tiledb.DenseArray(path, "w") as A:
        A[:] = a_orig


def make_2d_dense(path, attr_name="", attr_dtype=np.int64):
    a_orig = np.arange(1, 37).reshape(9, 4)

    dom = tiledb.Domain(
        tiledb.Dim(domain=(0, 8), tile=9, dtype=np.uint64),
        tiledb.Dim(domain=(0, 3), tile=4, dtype=np.uint64),
    )
    att = tiledb.Attr(name=attr_name, dtype=attr_dtype)
    schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=False)
    tiledb.DenseArray.create(path, schema)

    with tiledb.DenseArray(path, "w") as A:
        A[:] = a_orig


class TestMultiRangeAuxiliary(DiskTestCase):
    def test_shape_funcs(self):
        range1el = (((1, 1),),)
        self.assertEqual(mr_dense_result_shape(range1el), (1,))

        range1d = tuple([((1, 2), (4, 4))])
        self.assertEqual(mr_dense_result_shape(range1d), (3,))

        range2d1 = (((3, 6), (7, 7), (10, 12)), ((5, 7),))
        self.assertEqual(mr_dense_result_shape(range2d1), (8, 3))

        # range2d2 = ([(3, 6), (7, 7), (10, 12)], [(5, 7), (10, 10)])

    # def test_3d(self):
    #     range3d1 = (((2, 4),), ((3, 6),), ((1, 4), (5, 9)))
    #
    #     # self.assertEqual()

    def test_sel_to_ranges(self):
        class Obj(object):
            pass

        class IBI(object):
            def __getitem__(self, idx):
                return idx

        def make_arr(ndim):
            arr = Obj()
            arr.schema = Obj()
            arr.schema.domain = Obj()
            arr.schema.domain.ndim = ndim
            arr.schema.sparse = False
            arr.array = Obj()
            # place-holder for attribute that is not used in these tests
            arr.nonempty_domain = lambda: [()] * ndim
            return arr

        ibi = IBI()
        # ndim = 1
        arr = make_arr(1)
        self.assertEqual(getitem_ranges(arr, ibi[[1]]), (((1, 1),),))
        self.assertEqual(getitem_ranges(arr, ibi[[1, 2]]), (((1, 1), (2, 2)),))
        self.assertEqual(getitem_ranges(arr, ibi[slice(1, 2)]), (((1, 2),),))
        self.assertEqual(getitem_ranges(arr, ibi[1:2]), (((1, 2),),))

        # ndim = 2
        arr2 = make_arr(2)
        self.assertEqual(getitem_ranges(arr2, ibi[[1]]), (((1, 1),), ()))
        self.assertEqual(getitem_ranges(arr2, ibi[slice(1, 33)]), (((1, 33),), ()))
        self.assertEqual(
            getitem_ranges(arr2, ibi[[1, 2], [[1], slice(1, 3)]]),
            (((1, 1), (2, 2)), ((1, 1), (1, 3))),
        )

        # ndim = 3
        arr3 = make_arr(3)
        self.assertEqual(
            getitem_ranges(arr3, ibi[1, 2, 3]), (((1, 1),), ((2, 2),), ((3, 3),))
        )
        self.assertEqual(getitem_ranges(arr3, ibi[1, 2]), ((((1, 1),), ((2, 2),), ())))
        self.assertEqual(
            getitem_ranges(arr3, ibi[1:2, 3:4]), (((1, 2),), ((3, 4),), ())
        )
        self.assertEqual(
            getitem_ranges(arr3, ibi[1:2, 3:4, 5:6]), (((1, 2),), ((3, 4),), ((5, 6),))
        )
        self.assertEqual(
            getitem_ranges(arr3, ibi[[1], [2], [5, 6]]),
            (((1, 1),), ((2, 2),), ((5, 5), (6, 6))),
        )
        self.assertEqual(
            getitem_ranges(arr3, ibi[1, [slice(3, 6), 8], slice(4, 6)]),
            (((1, 1),), ((3, 6), (8, 8)), ((4, 6),)),
        )
        self.assertEqual(getitem_ranges(arr3, ibi[(1, 2)]), (((1, 1),), ((2, 2),), ()))
        self.assertEqual(getitem_ranges(arr3, ibi[[(1, 2)]]), (((1, 2),), (), ()))
        self.assertEqual(
            getitem_ranges(arr3, ibi[[(1, 2), 4], [slice(1, 4)]]),
            (((1, 2), (4, 4)), ((1, 4),), ()),
        )


class TestMultiRange(DiskTestCase):
    @pytest.mark.skipif(
        not has_pyarrow() or not has_pandas(),
        reason="pyarrow>=1.0 and/or pandas>=1.0,<3.0 not installed",
    )
    def test_return_arrow_indexers(self):
        uri = self.path("multirange_behavior_sparse")

        schema = tiledb.ArraySchema(
            domain=tiledb.Domain(
                tiledb.Dim(name="idx", domain=(-5, 5), dtype=np.int64)
            ),
            attrs=[tiledb.Attr(name="data", dtype=np.int64)],
        )
        tiledb.Array.create(uri, schema)
        data = np.random.randint(-10, 10, size=11)

        with tiledb.open(uri, "w") as A:
            A[:] = data

        with tiledb.open(uri, "r") as A:
            with self.assertRaisesRegex(
                tiledb.TileDBError,
                "Cannot initialize return_arrow with use_arrow=False",
            ):
                q = A.query(return_arrow=True, use_arrow=False)

            q = A.query(return_arrow=True)

            with self.assertRaisesRegex(
                tiledb.TileDBError,
                "`return_arrow=True` requires .df indexer",
            ):
                q[:]

            with self.assertRaisesRegex(
                tiledb.TileDBError,
                "`return_arrow=True` requires .df indexer",
            ):
                q.multi_index[:]

            assert_array_equal(q.df[:]["data"], data)

    @pytest.mark.skipif(
        not has_pyarrow() or not has_pandas(),
        reason="pyarrow>=1.0 and/or pandas>=1.0,<3.0 not installed",
    )
    @pytest.mark.parametrize("sparse", [True, False])
    def test_return_large_arrow_table(self, sparse):
        num = 2**16 - 1
        uri = self.path("test_return_large_arrow_table")
        dom = tiledb.Domain(tiledb.Dim(domain=(0, num - 1), dtype=np.uint16))
        att = tiledb.Attr(dtype=np.uint64)
        schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=sparse)
        tiledb.Array.create(uri, schema)

        expected_data = np.arange(num)

        with tiledb.open(uri, "w") as A:
            if sparse:
                A[np.arange(num)] = expected_data
            else:
                A[:] = expected_data

        with tiledb.open(uri, "r") as arr:
            actual_data = arr.query(return_arrow=True).df[:]
            assert_array_equal(actual_data[:][""], expected_data)

    def test_multirange_behavior(self):
        uri = self.path("multirange_behavior_sparse")

        schema = tiledb.ArraySchema(
            domain=tiledb.Domain(
                *[
                    tiledb.Dim(
                        name="idx",
                        domain=(-1.0, 0.7999999999999996),
                        tile=2.0,
                        dtype="float64",
                    )
                ]
            ),
            attrs=[tiledb.Attr(name="data", dtype="float64", var=False)],
            cell_order="row-major",
            tile_order="row-major",
            capacity=10000,
            sparse=True,
            allows_duplicates=True,
        )
        tiledb.SparseArray.create(uri, schema)
        data = np.random.rand(10)
        idx = np.arange(-1, 1, 0.2)

        with tiledb.open(uri, "w") as A:
            A[idx] = {"data": data}

        with tiledb.open(uri) as A:
            res = A.multi_index[:]
            # always return data
            self.assertTrue("data" in res)
            # return coordinates for sparse
            self.assertTrue("idx" in res)
            assert_array_equal(res["data"], data)
            assert_array_equal(res["idx"], idx)

        uri = self.path("multirange_behavior_dense")
        with tiledb.from_numpy(uri, data):
            pass

        with tiledb.open(uri) as B:
            res = B.multi_index[0:9]  # TODO: this should accept [:]
            # always return data
            self.assertTrue("" in res)
            # don't return coordinates for dense
            self.assertTrue("idx" not in res)

    def test_multirange_empty(self):
        path1 = self.path("test_multirange_empty_1d")
        make_1d_dense(path1, attr_dtype=np.uint16)
        with tiledb.open(path1) as A:
            res = A.multi_index[tiledb.EmptyRange]
            assert res[""].dtype == np.uint16
            assert res[""].shape == (0,)

        path2 = self.path("test_multirange_empty_2d")
        make_2d_dense(path2, attr_dtype=np.float32)
        with tiledb.open(path2) as A:
            res = A.multi_index[tiledb.EmptyRange]
            assert res[""].dtype == np.float32
            assert res[""].shape == (0,)

    def test_multirange_1d_1dim_ranges(self):
        path = self.path("test_multirange_1d_1dim_ranges")
        attr_name = "a"

        make_1d_dense(path, attr_name=attr_name)

        with tiledb.DenseArray(path) as A:
            ranges = (((0, 0),),)
            expected = np.array([0], dtype=np.int64)
            res = tiledb.libtiledb.multi_index(A, (attr_name,), ranges)
            a = res[attr_name]
            assert_array_equal(a, expected)
            self.assertEqual(a.dtype, expected.dtype)
            self.assertEqual(len(res.keys()), 2)

            ranges2 = (((1, 1), (5, 8)),)
            expected2 = np.array([1, 5, 6, 7, 8], dtype=np.int64)
            a2 = tiledb.libtiledb.multi_index(A, (attr_name,), ranges2)[attr_name]
            assert_array_equal(a2, expected2)
            self.assertEqual(a2.dtype, expected2.dtype)

    def test_multirange_2d_1dim_ranges(self):
        path = self.path("test_multirange_1dim_ranges")
        attr_name = "a"

        make_2d_dense(path, attr_name=attr_name)

        expected = np.array(
            [
                1,
                2,
                3,
                4,
                21,
                22,
                23,
                24,
                25,
                26,
                27,
                28,
                29,
                30,
                31,
                32,
                33,
                34,
                35,
                36,
            ],
            dtype=np.uint64,
        )

        ranges = (((0, 0), (5, 8)),)

        with tiledb.DenseArray(path) as A:
            a = tiledb.libtiledb.multi_index(A, (attr_name,), ranges)[attr_name]

            assert_array_equal(a, expected)

    def test_multirange_2d_2dim_ranges(self):
        path = self.path("test_multirange_2dim_ranges")
        attr_name = "a"

        make_2d_dense(path, attr_name=attr_name)

        expected = np.arange(1, 21)

        ranges = (((0, 4),), ((0, 3),))

        with tiledb.DenseArray(path) as A:
            a = tiledb.libtiledb.multi_index(A, (attr_name,), ranges)[attr_name]
            assert_array_equal(a, expected)

            # test slicing start=end on 1st dim at 0 (bug fix)
            assert_tail_equal(
                np.array([[1, 2, 3, 4]]),
                A.multi_index[:0][attr_name],
                A.multi_index[0:0][attr_name],
            )

            # test slicing start=end on 2nd dim at 0 (bug fix)
            assert_tail_equal(
                np.arange(1, 34, 4).reshape((9, 1)),
                A.multi_index[:, :0][attr_name],
                A.multi_index[:, 0:0][attr_name],
            )

            # test slicing start=end on 1st dim at 1
            assert_array_equal(np.array([[5, 6, 7, 8]]), A.multi_index[1:1][attr_name])

            # test slicing start=end on 2nd dim at 1
            assert_array_equal(
                np.arange(2, 35, 4).reshape((9, 1)), A.multi_index[:, 1:1][attr_name]
            )

            # test slicing start=end on 1st dim at max range
            assert_array_equal(
                np.array([[33, 34, 35, 36]]), A.multi_index[8:8][attr_name]
            )

            # test slicing start=end on 2nd dim at max range
            assert_tail_equal(
                np.arange(4, 37, 4).reshape((9, 1)), A.multi_index[:, 3:3][attr_name]
            )

    def test_multirange_1d_dense_int64(self):
        attr_name = ""
        path = self.path("multi_index_1d")

        dom = tiledb.Domain(
            tiledb.Dim(name="coords", domain=(-10, 10), tile=9, dtype=np.int64)
        )
        att = tiledb.Attr(name=attr_name, dtype=np.float32)
        schema = tiledb.ArraySchema(domain=dom, attrs=(att,))
        tiledb.DenseArray.create(path, schema)

        orig_array = np.random.rand(schema.domain.dim(0).size).astype(np.float32)
        with tiledb.open(path, "w") as A:
            A[:] = orig_array

        with tiledb.open(path) as A:
            # stepped ranges are not supported
            with self.assertRaises(ValueError):
                A.query(coords=True).multi_index[1::2]

            assert_array_equal(orig_array[[0, -1]], A.multi_index[[-10, 10]][attr_name])
            self.assertEqual(orig_array[0], A.multi_index[-10][attr_name])
            self.assertEqual(
                -10, A.query(coords=True).multi_index[-10]["coords"].view("i8")
            )
            assert_array_equal(orig_array[0:], A.multi_index[[(-10, 10)]][attr_name])
            assert_array_equal(
                orig_array[0:], A.multi_index[[slice(-10, 10)]][attr_name]
            )
            assert_array_equal(
                orig_array[0:10], A.multi_index[-10 : np.int64(-1)][attr_name]
            )
            assert_array_equal(orig_array, A.multi_index[:][attr_name])
            ned = A.nonempty_domain()[0]
            assert_array_equal(
                A.multi_index[ned[0] : ned[1]][attr_name], A.multi_index[:][attr_name]
            )

    def test_multirange_1d_sparse_double(self):
        attr_name = ""
        path = self.path("mr_1d_sparse_double")

        dom = tiledb.Domain(
            tiledb.Dim(name="coords", domain=(0, 30), tile=10, dtype=np.float64)
        )
        att = tiledb.Attr(name=attr_name, dtype=np.float64)
        schema = tiledb.ArraySchema(domain=dom, sparse=True, attrs=(att,))
        tiledb.SparseArray.create(path, schema)

        coords = np.linspace(0, 30, num=31)
        orig_array = np.random.rand(coords.size)

        with tiledb.open(path, "w") as A:
            A[coords] = orig_array

        with tiledb.open(path) as A:
            assert_array_equal(orig_array[[0]], A.multi_index[[0]][attr_name])
            assert_array_equal(orig_array[-1], A.multi_index[30][attr_name])
            assert_array_equal(orig_array[-1], A.multi_index[30.0][attr_name])
            assert_array_equal(
                orig_array[coords.size - 3 : coords.size],
                A.multi_index[
                    (28.0, 30.0),
                ][attr_name],
            )

            res = A.multi_index[slice(0, 5)]
            assert_array_equal(orig_array[0:6], res[attr_name])
            assert_array_equal(coords[0:6], res["coords"].astype(np.float64))

            # test slice range indexing
            ned = A.nonempty_domain()
            res = A.multi_index[: ned[0][1]]
            assert_array_equal(coords, res["coords"].astype(np.float64))

            res = A.multi_index[ned[0][0] : coords[15]]
            assert_array_equal(coords[:16], res["coords"].astype(np.float64))

    def test_multirange_2d_sparse_domain_utypes(self):
        attr_name = "foo"

        types = (np.uint8, np.uint16, np.uint32, np.uint64)

        for dtype in types:
            min = 0
            max = int(np.iinfo(dtype).max) - 1
            path = self.path("multi_index_2d_sparse_" + str(dtype.__name__))

            dom = tiledb.Domain(tiledb.Dim(domain=(min, max), tile=1, dtype=dtype))

            att = tiledb.Attr(name=attr_name, dtype=dtype)
            schema = tiledb.ArraySchema(domain=dom, sparse=True, attrs=(att,))
            tiledb.SparseArray.create(path, schema)

            coords = intspace(min, max, num=100, dtype=dtype)

            with tiledb.open(path, "w") as A:
                A[coords] = coords

            with tiledb.open(path) as A:
                res = A.multi_index[slice(coords[0], coords[-1])]
                assert_array_equal(res[attr_name], coords)
                assert_array_equal(res["__dim_0"].astype(dtype), coords)

                res = A.multi_index[coords[0]]
                assert_array_equal(res[attr_name], coords[0])
                assert_array_equal(res["__dim_0"].astype(dtype), coords[0])

                res = A.multi_index[coords[-1]]
                assert_array_equal(res[attr_name], coords[-1])
                assert_array_equal(res["__dim_0"].astype(dtype), coords[-1])

                midpoint = len(coords) // 2
                start = midpoint - 20
                stop = midpoint + 20
                srange = slice(coords[start], coords[stop])
                res = A.multi_index[srange]
                assert_array_equal(res[attr_name], coords[start : stop + 1])
                assert_array_equal(
                    res["__dim_0"].astype(dtype), coords[start : stop + 1]
                )

    def test_multirange_2d_sparse_float(self):
        attr_name = ""
        path = self.path("mr_2d_sparse_float")

        dom = tiledb.Domain(
            tiledb.Dim(domain=(0, 10), tile=1, dtype=np.float32),
            tiledb.Dim(domain=(0, 10), tile=1, dtype=np.float32),
        )
        att = tiledb.Attr(name=attr_name, dtype=np.float64)
        schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=True)
        tiledb.SparseArray.create(path, schema)

        orig_array = np.random.rand(11, 11)
        d1 = np.linspace(0, 10, num=11, dtype=np.float32)
        d2 = np.linspace(0, 10, num=11, dtype=np.float32)
        coords_d1, coords_d2 = np.meshgrid(d1, d2, indexing="ij")

        with tiledb.open(path, "w") as A:
            A[coords_d1.flatten(), coords_d2.flatten()] = orig_array

        with tiledb.open(path) as A:
            res = A.multi_index[[0], :]
            assert_array_equal(orig_array[[0], :].squeeze(), res[attr_name])
            assert_array_equal(coords_d1[0, :], res["__dim_0"])

            # ===
            res = A.multi_index[10, :]
            assert_array_equal(orig_array[[-1], :].squeeze(), res[attr_name])
            assert_array_equal(coords_d2[[-1], :].squeeze(), res["__dim_1"])

            # ===
            res = A.multi_index[[slice(0, 2), [5]]]
            assert_array_equal(
                np.vstack([orig_array[0:3, :], orig_array[5, :]]).flatten(),
                res[attr_name],
            )
            assert_array_equal(
                np.vstack((coords_d1[0:3], coords_d1[5])).flatten(), res["__dim_0"]
            )

            # ===
            res = A.multi_index[slice(0.0, 2.0), slice(2.0, 5.0)]
            assert_array_equal(orig_array[0:3, 2:6].flatten(), res[attr_name])
            assert_array_equal(coords_d1[0:3, 2:6].flatten(), res["__dim_0"])
            assert_array_equal(coords_d2[0:3, 2:6].flatten(), res["__dim_1"])
            res = A.multi_index[
                slice(np.float32(0.0), np.float32(2.0)),
                slice(np.float32(2.0), np.float32(5.0)),
            ]
            assert_array_equal(orig_array[0:3, 2:6].flatten(), res[attr_name])
            assert_array_equal(coords_d1[0:3, 2:6].flatten(), res["__dim_0"])
            assert_array_equal(coords_d2[0:3, 2:6].flatten(), res["__dim_1"])

    def test_multirange_1d_sparse_query(self):
        path = self.path("mr_1d_sparse_query")

        dom = tiledb.Domain(
            tiledb.Dim(name="coords", domain=(-100, 100), tile=1, dtype=np.float32)
        )
        attrs = [
            tiledb.Attr(name="U", dtype=np.float64),
            tiledb.Attr(name="V", dtype=np.uint32),
        ]

        schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True)
        tiledb.SparseArray.create(path, schema)

        U = np.random.rand(11)
        V = np.random.randint(0, np.iinfo(np.uint32).max, 11, dtype=np.uint32)

        coords = np.linspace(-10, 10, num=11, dtype=np.float32)
        data = {"U": U, "V": V}

        with tiledb.open(path, "w") as A:
            A[coords] = data

        with tiledb.open(path) as A:
            for k, d in data.items():
                Q = A.query(attrs=k)

                res = Q.multi_index[[-10]]
                assert_array_equal(d[[0]], res[k])

                assert_array_equal(coords[[0]], res["coords"].view("f4"))

                res = A.multi_index[10]
                assert_array_equal(d[[-1]].squeeze(), res[k])

                assert_array_equal(coords[[-1]], res["coords"].view("f4"))

                res = A.multi_index[[slice(coords[0], coords[2]), [coords[-1]]]]
                assert_array_equal(np.hstack([d[0:3], d[-1]]), res[k])

                # make sure full slice indexing works on query
                res = Q.multi_index[:]
                assert_array_equal(coords, res["coords"])

                # TODO: this should be an error
                # res = A.multi_index[10, :]
                # assert_array_equal(
                #    d[[-1]].squeeze(),
                #    res[k]
                # )

        with tiledb.open(path) as A:
            Q = A.query(coords=False, attrs=["U"])
            res = Q.multi_index[:]
            self.assertTrue("U" in res)
            self.assertTrue("V" not in res)
            self.assertTrue("coords" not in res)
            assert_array_equal(res["U"], data["U"])

    def test_multirange_1d_dense_vectorized(self):
        path = self.path("mr_1d_dense_vectorized")

        dom = tiledb.Domain(tiledb.Dim(domain=(0, 999), tile=1000, dtype=np.uint32))
        attrs = tiledb.Attr(name="", dtype=np.float64)

        schema = tiledb.ArraySchema(domain=dom, attrs=(attrs,), sparse=False)
        tiledb.DenseArray.create(path, schema)

        data = np.random.rand(1000)
        with tiledb.DenseArray(path, "w") as A:
            A[0] = data[0]
            A[-1] = data[-1]
            A[:] = data

        for _ in range(0, 50):
            with tiledb.DenseArray(path) as A:
                idxs = random.sample(range(0, 999), k=100)
                res = A.multi_index[idxs]
                assert_array_equal(data[idxs], res[""])

    def test_multirange_2d_dense_float(self):
        attr_name = ""
        path = self.path("multirange_2d_dense_float")

        dom = tiledb.Domain(
            tiledb.Dim(domain=(0, 10), tile=1, dtype=np.int64),
            tiledb.Dim(domain=(0, 10), tile=1, dtype=np.int64),
        )
        att = tiledb.Attr(name=attr_name, dtype=np.float64)
        schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=False)
        tiledb.DenseArray.create(path, schema)

        orig_array = np.random.rand(11, 11)

        with tiledb.open(path, "w") as A:
            A[:] = orig_array

        with tiledb.open(path) as A:
            assert_array_equal(orig_array[[0], :], A.multi_index[[0], :][attr_name])
            assert_array_equal(
                orig_array[[-1, -1], :], A.multi_index[[10, 10], :][attr_name]
            )
            assert_array_equal(
                orig_array[0:4, 7:10], A.multi_index[[(0, 3)], slice(7, 9)][attr_name]
            )
            assert_array_equal(orig_array[:, :], A.multi_index[:, :][attr_name])
            # TODO this should be an error to match NumPy 1.12 semantics
            # assert_array_equal(
            #    orig_array[0:4,7:10],
            #    A.multi_index[[(np.float64(0),np.float64(3.0))], slice(7,9)][attr_name]
            # )

    @pytest.mark.parametrize("dtype", SUPPORTED_DATETIME64_DTYPES)
    def test_multirange_1d_sparse_datetime64(self, dtype):
        path = self.path("multirange_1d_sparse_datetime64")

        dates = rand_datetime64_array(10, dtype=dtype)
        dom = tiledb.Domain(
            tiledb.Dim(domain=(dates.min(), dates.max()), dtype=dtype, tile=1)
        )

        attr_name = ""
        att = tiledb.Attr(name=attr_name, dtype=dtype)
        schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=True)
        tiledb.SparseArray.create(path, schema)

        with tiledb.SparseArray(path, mode="w") as T:
            T[dates] = dates

        with tiledb.open(path) as A:
            res = A.multi_index[:]
            # check full range
            assert_tail_equal(dates, res[""], res["__dim_0"])

            # check range pairs
            for i in range(len(dates) - 1):
                start, stop = dates[i : i + 2]
                assert_tail_equal(
                    dates[i : i + 2],
                    A.multi_index[start:stop][""],
                    A.multi_index[start:stop]["__dim_0"],
                )

    def test_fix_473_sparse_index_bug(self):
        # test of fix for issue raised in
        # https://github.com/TileDB-Inc/TileDB-Py/pull/473#issuecomment-784675012

        uri = self.path("test_fix_473_sparse_index_bug")
        dom = tiledb.Domain(
            tiledb.Dim(name="x", domain=(0, 2**64 - 2), tile=1, dtype=np.uint64)
        )
        schema = tiledb.ArraySchema(
            domain=dom, sparse=True, attrs=[tiledb.Attr(name="a", dtype=np.uint64)]
        )

        tiledb.SparseArray.create(uri, schema)

        slice_index = slice(0, 4, None)

        with tiledb.SparseArray(uri, mode="r") as A:
            data = A.multi_index[slice_index]

            assert_array_equal(data["a"], np.array([], dtype=np.uint64))
            assert_array_equal(A.multi_index[:], [])

        with tiledb.open(uri, mode="w") as A:
            A[[10]] = {"a": [10]}

        with tiledb.open(uri) as A:
            assert_tail_equal(
                A.multi_index[slice_index]["a"],
                A.multi_index[:],
                A.multi_index[0:],
                A.multi_index[1:],
                A.multi_index[:10],
                A.multi_index[:11],
                np.array([], dtype=np.uint64),
            )

    @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed")
    def test_fixed_multi_attr_df(self):
        uri = self.path("test_fixed_multi_attr_df")
        dom = tiledb.Domain(
            tiledb.Dim(name="dim", domain=(0, 0), tile=None, dtype=np.int32)
        )
        schema = tiledb.ArraySchema(
            domain=dom,
            sparse=True,
            attrs=[
                tiledb.Attr(
                    name="111", dtype=[("", np.int32), ("", np.int32), ("", np.int32)]
                )
            ],
        )

        tiledb.SparseArray.create(uri, schema)

        data_111 = np.array(
            [(1, 1, 1)], dtype=[("", np.int32), ("", np.int32), ("", np.int32)]
        )
        with tiledb.SparseArray(uri, mode="w") as A:
            A[0] = data_111

        with tiledb.SparseArray(uri, mode="r") as A:
            result = A.query(attrs=["111"])[0]
            assert_array_equal(result["111"], data_111)

            with self.assertRaises(tiledb.TileDBError):
                result = A.query(attrs=["111"]).df[0]

            result = A.query(attrs=["111"], use_arrow=False)
            assert_array_equal(result.df[0]["111"], data_111)

    @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed")
    def test_var_multi_attr_df(self):
        uri = self.path("test_var_multi_attr_df")
        dom = tiledb.Domain(
            tiledb.Dim(name="dim", domain=(0, 2), tile=None, dtype=np.int32)
        )
        schema = tiledb.ArraySchema(
            domain=dom,
            sparse=True,
            attrs=[tiledb.Attr(name="1s", dtype=np.int32, var=True)],
        )

        tiledb.SparseArray.create(uri, schema)

        data = np.array(
            [
                np.array([1], dtype=np.int32),
                np.array([1, 1], dtype=np.int32),
                np.array([1, 1, 1], dtype=np.int32),
            ],
            dtype="O",
        )
        with tiledb.SparseArray(uri, mode="w") as A:
            A[[0, 1, 2]] = data

        with tiledb.SparseArray(uri, mode="r") as A:
            result = A.query(attrs=["1s"])
            assert_array_equal(result[0]["1s"][0], data[0])
            assert_array_equal(result[1]["1s"][0], data[1])
            assert_array_equal(result[2]["1s"][0], data[2])

            with self.assertRaises(tiledb.TileDBError):
                result = A.query(attrs=["1s"]).df[0]

            result = A.query(attrs=["1s"], use_arrow=False)
            assert_array_equal(result.df[0]["1s"][0], data[0])
            assert_array_equal(result.df[1]["1s"][0], data[1])
            assert_array_equal(result.df[2]["1s"][0], data[2])

    def test_multi_index_with_implicit_full_string_range(self):
        uri = self.path("test_multi_index_with_implicit_full_string_range")
        dom = tiledb.Domain(
            tiledb.Dim(name="dint", domain=(0, 4), tile=5, dtype=np.int32),
            tiledb.Dim(name="dstr", domain=(None, None), tile=None, dtype=np.bytes_),
        )
        schema = tiledb.ArraySchema(
            domain=dom, sparse=True, attrs=[tiledb.Attr(name="", dtype=np.int32)]
        )

        tiledb.Array.create(uri, schema)
        with tiledb.open(uri, mode="w") as A:
            d1 = np.concatenate((np.arange(5), np.arange(5)))
            d2 = np.asarray(
                ["a", "b", "ab", "ab", "c", "c", "c", "c", "d", "e"], dtype=np.bytes_
            )
            A[d1, d2] = np.array(np.random.randint(10, size=10), dtype=np.int32)

        with tiledb.open(uri, mode="r") as A:
            assert_array_equal(A[:][""], A.multi_index[:][""])
            assert_array_equal(A.multi_index[:][""], A.multi_index[:, :][""])

            assert_array_equal(A[1:4][""], A.multi_index[1:3][""])
            assert_array_equal(A.multi_index[1:3][""], A.multi_index[1:3, :][""])

            assert_array_equal(A[0][""], A.multi_index[0][""])
            assert_array_equal(A.multi_index[0][""], A.multi_index[0, :][""])

    def test_multi_index_open_timestamp_with_empty_nonempty_domain(self):
        uri = self.path("test_multi_index_open_timestamp_with_empty_nonempty_domain")
        dom = tiledb.Domain(tiledb.Dim(domain=(1, 3)))
        attr = tiledb.Attr(name="", dtype=np.int32)
        schema = tiledb.ArraySchema(domain=dom, sparse=True, attrs=[attr])
        tiledb.Array.create(uri, schema)

        with tiledb.open(uri, mode="w", timestamp=2) as A:
            d1 = np.array(np.random.randint(1, 11, size=3, dtype=np.int32))
            A[np.arange(1, 4)] = d1

        with tiledb.open(uri, mode="r", timestamp=1) as A:
            assert A.nonempty_domain() is None
            assert_array_equal(A.multi_index[:][""], A[:][""])

    @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed")
    def test_multi_index_query_args(self):
        uri = self.path("test_multi_index_query_args")
        schema = tiledb.ArraySchema(
            domain=tiledb.Domain(tiledb.Dim(name="dim", domain=(0, 9), dtype=np.uint8)),
            sparse=True,
            attrs=[
                tiledb.Attr(name="a", dtype=np.uint8),
                tiledb.Attr(name="b", dtype=np.uint8),
            ],
        )
        tiledb.Array.create(uri, schema)

        a = np.array(np.random.randint(10, size=10), dtype=np.int8)
        b = np.array(np.random.randint(10, size=10), dtype=np.int8)

        with tiledb.open(uri, mode="w") as A:
            A[np.arange(10)] = {"a": a, "b": b}

        with tiledb.open(uri, mode="r") as A:
            q = A.query(cond="a >= 5", attrs=["a"])
            assert {"a", "dim"} == q.multi_index[:].keys() == q[:].keys()
            assert_array_equal(q.multi_index[:]["a"], q[:]["a"])
            assert_array_equal(q.multi_index[:]["a"], q.df[:]["a"])
            assert all(q[:]["a"] >= 5)

    @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed")
    def test_multi_index_timing(self):
        path = self.path("test_multi_index_timing")
        attr_name = "a"

        make_1d_dense(path, attr_name=attr_name)
        tiledb.stats_enable()
        with tiledb.open(path) as A:
            assert_array_equal(A.df[:][attr_name], np.arange(36))
            internal_stats = tiledb.main.python_internal_stats()
            assert "py.getitem_time :" in internal_stats
            assert "py.getitem_time.buffer_conversion_time :" in internal_stats
            assert "py.getitem_time.pandas_index_update_time :" in internal_stats
        tiledb.stats_disable()

    @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed")
    def test_fixed_width_char(self):
        uri = self.path("test_fixed_width_char")
        schema = tiledb.ArraySchema(
            domain=tiledb.Domain(tiledb.Dim(name="dim", domain=(0, 2), dtype=np.uint8)),
            attrs=[tiledb.Attr(dtype="|S3")],
        )
        tiledb.Array.create(uri, schema)

        data = np.array(["cat", "dog", "hog"], dtype="|S3")

        with tiledb.open(uri, mode="w") as A:
            A[:] = data

        with tiledb.open(uri, mode="r") as A:
            assert all(A.query(use_arrow=True).df[:][""] == data)

    @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed")
    def test_empty_idx(self):
        uri = self.path("test_empty_idx")

        schema = tiledb.ArraySchema(
            domain=tiledb.Domain(tiledb.Dim(name="dim", domain=(0, 9), dtype=np.uint8)),
            sparse=True,
            attrs=[tiledb.Attr(name="a", dtype=np.float64)],
        )
        tiledb.Array.create(uri, schema)

        data = np.array(np.random.randint(10, size=10), dtype=np.float64)

        with tiledb.open(uri, mode="w") as A:
            A[np.arange(10)] = data

        with tiledb.open(uri, mode="r") as A:
            assert_array_equal(A.df[tiledb.EmptyRange]["a"], [])
            assert_array_equal(A.multi_index[tiledb.EmptyRange]["a"], [])
            assert_array_equal(A.df[[]]["a"], [])
            assert_array_equal(A.multi_index[[]]["a"], [])
            assert_array_equal(A.df[()]["a"], [])
            assert_array_equal(A.multi_index[()]["a"], [])


# parametrize dtype and sparse
@pytest.mark.parametrize(
    "dim_dtype",
    [
        np.int64,
        np.uint64,
        np.int32,
        np.uint32,
        np.int16,
        np.uint16,
        np.int8,
        np.uint8,
    ],
)
class TestMultiIndexND(DiskTestCase):
    def test_multi_index_ndarray(self, dim_dtype):
        # TODO support for dense?
        sparse = True  # ndarray indexing currently only supported for sparse

        path = self.path("test_multi_index_ndarray")

        ncells = 10
        data = np.arange(ncells - 1)
        coords = np.arange(ncells - 1)

        # use negative range for sparse
        if sparse and np.issubdtype(dim_dtype, np.signedinteger):
            coords -= 4

        dom = tiledb.Domain(
            tiledb.Dim(domain=(coords.min(), coords.max()), dtype=dim_dtype)
        )
        att = tiledb.Attr(dtype=np.int8)
        schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=sparse)
        tiledb.Array.create(path, schema)

        with tiledb.open(path, "w") as A:
            if sparse:
                A[coords] = data
            else:
                A[:] = data

        with tiledb.open(path) as A:
            assert_dict_arrays_equal(
                A.multi_index[coords.tolist()], A.multi_index[coords]
            )
            assert_dict_arrays_equal(
                A.multi_index[coords.tolist()], A.multi_index[coords]
            )

    def test_multi_index_ndarray_2d(self, dim_dtype):
        sparse = False

        path = self.path("test_multi_index_ndarray_2d")

        ncells = 10
        ext = ncells - 1
        if sparse:
            data = np.arange(ext)
        else:
            data = np.arange(ext**2).reshape(ext, ext)
        d1_coords = np.arange(ext)
        d2_coords = np.arange(ext, 0, -1)

        # use negative range for sparse
        if sparse and np.issubdtype(dim_dtype, np.signedinteger):
            d1_coords -= 4

        d1 = tiledb.Dim(
            name="d1", domain=(d1_coords.min(), d1_coords.max()), dtype=dim_dtype
        )
        d2 = tiledb.Dim(
            name="d2", domain=(d2_coords.min(), d2_coords.max()), dtype=dim_dtype
        )
        dom = tiledb.Domain([d1, d2])

        att = tiledb.Attr(dtype=np.int8)
        schema = tiledb.ArraySchema(domain=dom, attrs=(att,), sparse=sparse)
        tiledb.Array.create(path, schema)

        with tiledb.open(path, "w") as A:
            if sparse:
                A[d1_coords.tolist(), d2_coords.tolist()] = {"": data}
            else:
                A[:] = data
                # raise ValueError("Test only support sparse")

        with tiledb.open(path) as A:
            assert_dict_arrays_equal(
                A.multi_index[d1_coords.tolist(), d2_coords.tolist()],
                A.multi_index[d1_coords, d2_coords],
            )

            # note: np.flip below because coords are in reverse order, which is how
            #       tiledb will return the results for the first query, but not second
            assert_dict_arrays_equal(
                A.multi_index[d1_coords.tolist(), np.flip(d2_coords.tolist())],
                A.multi_index[d1_coords, :],
            )

            slc = slice(0, ncells - 1, 2)
            assert_dict_arrays_equal(
                A.multi_index[d1_coords[slc].tolist(), :],
                A.multi_index[d1_coords[slc], :],
            )
            assert_dict_arrays_equal(
                A.multi_index[:, d2_coords[slc]], A.multi_index[:, d2_coords[slc]]
            )