| import string |
|
|
| import numpy as np |
| import pytest |
| from numpy.testing import assert_array_equal |
|
|
| import tiledb |
|
|
| from .common import DiskTestCase, has_pandas, rand_utf8 |
|
|
|
|
| class QueryConditionTest(DiskTestCase): |
| def filter_dense(self, data, mask): |
| if isinstance(mask, np.ndarray): |
| mask = mask[0] |
|
|
| if isinstance(mask, float): |
| return data[np.invert(np.isnan(data))] |
|
|
| if isinstance(mask, np.timedelta64): |
| return data[np.invert(np.isnat(data))] |
|
|
| if isinstance(mask, (str, bytes)): |
| return data[np.invert(data == mask)] |
|
|
| return data[data != mask] |
|
|
| def create_input_array_UIDSA(self, sparse): |
| path = self.path("input_array_UIDSA") |
|
|
| dom = tiledb.Domain( |
| tiledb.Dim(name="d", domain=(1, 10), tile=1, dtype=np.uint32) |
| ) |
| attrs = [ |
| tiledb.Attr(name="U", dtype=np.uint32), |
| tiledb.Attr(name="I", dtype=np.int64), |
| tiledb.Attr(name="D", dtype=np.float64), |
| tiledb.Attr(name="S", dtype=np.dtype("|S1"), var=False), |
| tiledb.Attr(name="A", dtype="ascii", var=True), |
| tiledb.Attr(name="UTF", dtype=np.dtype("U"), var=True), |
| ] |
|
|
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=sparse) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, "w") as arr: |
| data = { |
| "U": np.random.randint(1, 10, 10), |
| "I": np.random.randint(-5, 5, 10), |
| "D": np.random.rand(10), |
| "S": np.array(list(string.ascii_lowercase[:10]), dtype="|S1"), |
| "A": np.array( |
| list(string.ascii_lowercase[i] * (i + 1) for i in range(10)), |
| dtype="|S", |
| ), |
| "UTF": np.array( |
| ["$", "£$", "€ह£$", "한ह£", "£$𐍈"] |
| + [rand_utf8(np.random.randint(1, 100)) for _ in range(5)], |
| dtype="|U0", |
| ), |
| } |
|
|
| if sparse: |
| arr[np.arange(1, 11)] = data |
| else: |
| arr[:] = data |
|
|
| return path |
|
|
| def setUp(self): |
| super().setUp() |
| if not tiledb.libtiledb.version() >= (2, 2, 3): |
| pytest.skip("Only run QueryCondition test with TileDB>=2.2.3") |
|
|
| @pytest.mark.parametrize("sparse", [True, False]) |
| def test_errors(self, sparse): |
| uri = self.create_input_array_UIDSA(sparse) |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| with tiledb.open(uri) as A: |
| A.query(cond="1.324 < 1")[:] |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| with tiledb.open(uri) as A: |
| A.query(cond="foo >= bar")[:] |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| with tiledb.open(uri) as A: |
| A.query(cond="'foo' == 'bar'")[:] |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| with tiledb.open(uri) as A: |
| A.query(cond="U < 10000000000000000000000.0", attrs=["U"])[:] |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| with tiledb.open(uri) as A: |
| A.query(cond="D", attrs=["D"])[:] |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| with tiledb.open(uri) as A: |
| A.query(cond="D,", attrs=["D"])[:] |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| with tiledb.open(uri) as A: |
| A.query(cond="D > ", attrs=["D"])[:] |
|
|
| def test_qc_dense(self): |
| path = self.path("test_qc_dense") |
|
|
| dom = tiledb.Domain( |
| tiledb.Dim(name="d", domain=(1, 10), tile=1, dtype=np.uint8) |
| ) |
| attrs = [tiledb.Attr(name="a", dtype=np.uint8)] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=False) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path) as A: |
| A.query(cond="a < 5") |
|
|
| def test_unsigned_sparse(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| A.query(cond="U < 5", attrs=["U"])[:] |
|
|
| result = A.query(cond="U < 5", attrs=["U"])[:] |
| assert all(result["U"] < 5) |
|
|
| def test_unsigned_dense(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=False)) as A: |
| mask = A.attr("U").fill |
|
|
| A.query(cond="U < 5", attrs=["U"])[:] |
|
|
| result = A.query(cond="U < 5", attrs=["U"])[:] |
| assert all(self.filter_dense(result["U"], mask) < 5) |
|
|
| def test_signed_sparse(self): |
| uri = self.create_input_array_UIDSA(sparse=True) |
|
|
| with tiledb.open(uri) as A: |
| result = A.query(cond="I < 1", attrs=["I"])[:] |
| assert all(result["I"] < 1) |
|
|
| result = A.query(cond="I < +1", attrs=["I"])[:] |
| assert all(result["I"] < +1) |
|
|
| result = A.query(cond="I < ---1", attrs=["I"])[:] |
| assert all(result["I"] < ---1) |
|
|
| result = A.query(cond="-5 < I < 5", attrs=["I"])[:] |
| assert all(-5 < result["I"]) |
| assert all(result["I"] < 5) |
|
|
| def test_signed_dense(self): |
| uri = self.create_input_array_UIDSA(sparse=False) |
|
|
| with tiledb.open(uri) as A: |
| mask = A.attr("I").fill |
|
|
| result = A.query(cond="I < 1", attrs=["I"])[:] |
| assert all(self.filter_dense(result["I"], mask) < 1) |
|
|
| result = A.query(cond="I < +1", attrs=["I"])[:] |
| assert all(self.filter_dense(result["I"], mask) < +1) |
|
|
| result = A.query(cond="I < ---1", attrs=["I"])[:] |
| assert all(self.filter_dense(result["I"], mask) < ---1) |
|
|
| result = A.query(cond="-5 < I < 5", attrs=["I"])[:] |
| assert all(-5 < self.filter_dense(result["I"], mask)) |
| assert all(self.filter_dense(result["I"], mask) < 5) |
|
|
| def test_floats_sparse(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| result = A.query(cond="D > 5.0", attrs=["D"])[:] |
| assert all(result["D"] > 5.0) |
|
|
| result = A.query(cond="(D > 0.7) & (D < 3.5)", attrs=["D"])[:] |
| assert all((result["D"] > 0.7) & (result["D"] < 3.5)) |
|
|
| result = A.query(cond="0.2 < D < 0.75", attrs=["D", "D"])[:] |
| assert all(0.2 < result["D"]) |
| assert all(result["D"] < 0.75) |
|
|
| def test_floats_dense(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=False)) as A: |
| mask = A.attr("D").fill |
|
|
| result = A.query(cond="D > 5.0", attrs=["D"])[:] |
| assert all(self.filter_dense(result["D"], mask) > 5.0) |
|
|
| result = A.query(cond="(D > 0.7) & (D < 3.5)", attrs=["D"])[:] |
| assert all(self.filter_dense(result["D"], mask) > 0.7) |
| assert all(self.filter_dense(result["D"], mask) < 3.5) |
|
|
| result = A.query(cond="0.2 < D < 0.75", attrs=["D", "D"])[:] |
| assert all(0.2 < self.filter_dense(result["D"], mask)) |
| assert all(self.filter_dense(result["D"], mask) < 0.75) |
|
|
| def test_string_sparse(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| with self.assertRaises(tiledb.TileDBError) as exc_info: |
| A.query(cond="S == c", attrs=["S"])[:] |
| assert ( |
| "right-hand sides must be constant expressions, not variables -- did you mean to quote the right-hand side as a string?" |
| in str(exc_info.value) |
| ) |
|
|
| result = A.query(cond="S == 'c'", attrs=["S"])[:] |
| assert len(result["S"]) == 1 |
| assert result["S"][0] == b"c" |
|
|
| result = A.query(cond="A == 'a'", attrs=["A"])[:] |
| assert len(result["A"]) == 1 |
| assert result["A"][0] == b"a" |
|
|
| if tiledb.libtiledb.version() > (2, 14): |
| for t in A.query(attrs=["UTF"])[:]["UTF"]: |
| cond = f"""UTF == '{t}'""" |
| result = A.query(cond=cond, attrs=["UTF"])[:] |
| assert result["UTF"] == t |
|
|
| def test_string_dense(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=False)) as A: |
| with self.assertRaises(tiledb.TileDBError) as exc_info: |
| A.query(cond="S == ccc", attrs=["S"])[:] |
| assert ( |
| "right-hand sides must be constant expressions, not variables -- did you mean to quote the right-hand side as a string?" |
| in str(exc_info.value) |
| ) |
|
|
| result = A.query(cond="S == 'ccc'", attrs=["S"])[:] |
| assert all(self.filter_dense(result["S"], A.attr("S").fill) == b"c") |
|
|
| result = A.query(cond="A == 'ccc'", attrs=["A"])[:] |
| assert all(self.filter_dense(result["A"], A.attr("A").fill) == b"ccc") |
|
|
| if tiledb.libtiledb.version() > (2, 14): |
| for t in A.query(attrs=["UTF"])[:]["UTF"]: |
| cond = f"""UTF == '{t}'""" |
| result = A.query(cond=cond, attrs=["UTF"])[:] |
| assert all( |
| self.filter_dense(result["UTF"], A.attr("UTF").fill) == t |
| ) |
|
|
| def test_combined_types_sparse(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| qc = "(I > 0) & ((-3 < D) & (D < 3.0))" |
| result = A.query(cond=qc, attrs=["I", "D"])[:] |
| assert all((result["I"] > 0) & ((-3 < result["D"]) & (result["D"] < 3.0))) |
|
|
| qc = "U >= 3 and 0.7 < D" |
| result = A.query(cond=qc, attrs=["U", "D"])[:] |
| assert all(result["U"] >= 3) & all(0.7 < result["D"]) |
|
|
| qc = "(0.2 < D and D < 0.75) and (-5 < I < 5)" |
| result = A.query(cond=qc, attrs=["D", "I"])[:] |
| assert all((0.2 < result["D"]) & (result["D"] < 0.75)) |
| assert all((-5 < result["I"]) & (result["I"] < 5)) |
|
|
| qc = "(-5 < I <= -1) and (0.2 < D < 0.75)" |
| result = A.query(cond=qc, attrs=["D", "I"])[:] |
| assert all((0.2 < result["D"]) & (result["D"] < 0.75)) |
| assert all((-5 < result["I"]) & (result["I"] <= -1)) |
|
|
| qc = "(0.2 < D < 0.75) and (-5 < I < 5)" |
| result = A.query(cond=qc, attrs=["D", "I"])[:] |
| assert all((0.2 < result["D"]) & (result["D"] < 0.75)) |
| assert all((-5 < result["I"]) & (result["I"] < 5)) |
|
|
| def test_combined_types_dense(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=False)) as A: |
| mask_U = A.attr("U").fill |
| mask_I = A.attr("I").fill |
| mask_D = A.attr("D").fill |
|
|
| qc = "(I > 0) & ((-3 < D) & (D < 3.0))" |
| result = A.query(cond=qc, attrs=["I", "D"])[:] |
| res_I = self.filter_dense(result["I"], mask_I) |
| res_D = self.filter_dense(result["D"], mask_D) |
| assert all(res_I > 0) & all(-3 < res_D) & all(res_D < 3.0) |
|
|
| qc = "U >= 3 and 0.7 < D" |
| result = A.query(cond=qc, attrs=["U", "D"])[:] |
| res_U = self.filter_dense(result["U"], mask_U) |
| res_D = self.filter_dense(result["D"], mask_D) |
| assert all(res_U >= 3) & all(0.7 < res_D) |
|
|
| qc = "(0.2 < D and D < 0.75) and (-5 < I < 5)" |
| result = A.query(cond=qc, attrs=["D", "I"])[:] |
| res_D = self.filter_dense(result["D"], mask_D) |
| res_I = self.filter_dense(result["I"], mask_I) |
| assert all((0.2 < res_D) & (res_D < 0.75)) |
| assert all((-5 < res_I) & (res_I < 5)) |
|
|
| qc = "(-5 < I <= -1) and (0.2 < D < 0.75)" |
| result = A.query(cond=qc, attrs=["D", "I"])[:] |
| res_D = self.filter_dense(result["D"], mask_D) |
| res_I = self.filter_dense(result["I"], mask_I) |
| assert all((0.2 < res_D) & (res_D < 0.75)) |
| assert all((-5 < res_I) & (res_I <= -1)) |
|
|
| qc = "(0.2 < D < 0.75) and (-5 < I < 5)" |
| result = A.query(cond=qc, attrs=["D", "I"])[:] |
| res_D = self.filter_dense(result["D"], mask_D) |
| res_I = self.filter_dense(result["I"], mask_I) |
| assert all((0.2 < res_D) & (res_D < 0.75)) |
| assert all((-5 < res_I) & (res_I < 5)) |
|
|
| def test_check_attrs_sparse(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| result = A.query(cond="U < 0.1", attrs=["U"])[:] |
| assert all(result["U"] < 0.1) |
|
|
| result = A.query(cond="U < 1.0", attrs=["U"])[:] |
| assert all(result["U"] < 1.0) |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| A.query(cond="U < '1'", attrs=["U"])[:] |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| A.query(cond="U < 'one'", attrs=["U"])[:] |
|
|
| def test_check_attrs_dense(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=False)) as A: |
| mask = A.attr("U").fill |
|
|
| result = A.query(cond="U < 0.1", attrs=["U"])[:] |
| assert all(self.filter_dense(result["U"], mask) < 0.1) |
|
|
| result = A.query(cond="U < 1.0", attrs=["U"])[:] |
| assert all(self.filter_dense(result["U"], mask) < 1.0) |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| A.query(cond="U < '1'", attrs=["U"])[:] |
|
|
| with self.assertRaises(tiledb.TileDBError): |
| A.query(cond="U < 'one'", attrs=["U"])[:] |
|
|
| def test_attr_and_val_casting_num(self): |
| path = self.path("test_attr_and_val_casting_num") |
|
|
| dom = tiledb.Domain( |
| tiledb.Dim(name="dim", domain=(1, 10), tile=1, dtype=np.uint32) |
| ) |
| attrs = [ |
| tiledb.Attr(name="64-bit integer", dtype=np.int64), |
| tiledb.Attr(name="double", dtype=np.float64), |
| ] |
|
|
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, "w") as arr: |
| arr[np.arange(1, 11)] = { |
| "64-bit integer": np.random.randint(-5, 5, 10), |
| "double": np.random.rand(10), |
| } |
|
|
| with tiledb.open(path) as arr: |
| result = arr.query(cond="attr('64-bit integer') <= val(0)")[:] |
| assert all(result["64-bit integer"] <= 0) |
|
|
| result = arr.query(cond="attr('64-bit integer') <= 0")[:] |
| assert all(result["64-bit integer"] <= 0) |
|
|
| result = arr.query(cond="double <= 0.5")[:] |
| assert all(result["double"] <= 0.5) |
|
|
| result = arr.query(cond="attr('double') <= 0.5")[:] |
| assert all(result["double"] <= 0.5) |
|
|
| result = arr.query(cond="double <= val(0.5)")[:] |
| assert all(result["double"] <= 0.5) |
|
|
| result = arr.query(cond="attr('double') <= val(0.5)")[:] |
| assert all(result["double"] <= 0.5) |
|
|
| def test_casting_str(self): |
| path = self.path("test_attr_and_val_casting_str") |
|
|
| dom = tiledb.Domain(tiledb.Dim(name="dim with spaces", dtype="ascii")) |
| attrs = [tiledb.Attr(name="attr with spaces", dtype="ascii", var=True)] |
|
|
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| A = np.array( |
| [ |
| "value with spaces", |
| "nospaces", |
| "value with spaces", |
| "another value", |
| "", |
| ] |
| ) |
|
|
| with tiledb.open(path, "w") as arr: |
| arr[["a", "b", "c", "d", "e"]] = {"attr with spaces": A} |
|
|
| with tiledb.open(path) as arr: |
| qc = "attr('attr with spaces') == 'value with spaces'" |
| result = arr.query(cond=qc)[:] |
| assert list(result["dim with spaces"]) == [b"a", b"c"] |
|
|
| with pytest.raises(tiledb.TileDBError) as exc_info: |
| result = arr.query(cond="dim('attr with spaces') == 'd'")[:] |
| assert "is not a dimension" in str(exc_info.value) |
|
|
| qc = "attr('attr with spaces') == val('value with spaces')" |
| result = arr.query(cond=qc)[:] |
| assert list(result["dim with spaces"]) == [b"a", b"c"] |
|
|
| with pytest.raises(tiledb.TileDBError) as exc_info: |
| result = arr.query(cond="attr('dim with spaces') == 'd'")[:] |
| assert "is not an attribute" in str(exc_info.value) |
|
|
| result = arr.query(cond="dim('dim with spaces') == 'd'")[:] |
| assert list(result["dim with spaces"]) == [b"d"] |
|
|
| @pytest.mark.skipif( |
| tiledb.libtiledb.version() < (2, 7, 0), |
| reason="var-length np.bytes_ query condition support introduced in 2.7.0", |
| ) |
| def test_var_length_str(self): |
| path = self.path("test_var_length_str") |
|
|
| dom = tiledb.Domain(tiledb.Dim(name="d", domain=(0, 4))) |
| attrs = [ |
| tiledb.Attr(name="ascii", dtype="ascii", var=True), |
| tiledb.Attr(name="bytes", dtype=np.bytes_, var=True), |
| ] |
|
|
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| def create_array(func): |
| return np.array([func[i - 1] * i for i in range(1, 6)], dtype=np.bytes_) |
|
|
| ascii_data = create_array(string.ascii_lowercase) |
| bytes_data = create_array(string.ascii_uppercase) |
|
|
| with tiledb.open(path, "w") as arr: |
| arr[np.arange(5)] = {"ascii": ascii_data, "bytes": bytes_data} |
|
|
| with tiledb.open(path, "r") as arr: |
| for s in ascii_data: |
| result = arr.query(cond=f"ascii == '{s.decode()}'")[:] |
| assert result["ascii"][0] == s |
|
|
| for s in bytes_data: |
| result = arr.query(cond=f"bytes == '{s.decode()}'")[:] |
| assert result["bytes"][0] == s |
|
|
| @pytest.mark.skipif( |
| tiledb.libtiledb.version() < (2, 10, 0), |
| reason="OR query condition operator introduced in libtiledb 2.10", |
| ) |
| def test_or_sparse(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| result = A.query(cond="(D < 0.25) | (D > 0.75)", attrs=["D"])[:] |
| assert all((result["D"] < 0.25) | (result["D"] > 0.75)) |
|
|
| result = A.query(cond="(D < 0.25) or (D > 0.75)", attrs=["D"])[:] |
| assert all((result["D"] < 0.25) | (result["D"] > 0.75)) |
|
|
| @pytest.mark.skipif( |
| tiledb.libtiledb.version() < (2, 10, 0), |
| reason="OR query condition operator introduced in libtiledb 2.10", |
| ) |
| def test_or_dense(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=False)) as A: |
| mask = A.attr("D").fill |
|
|
| result = A.query(cond="(D < 0.25) | (D > 0.75)", attrs=["D"])[:] |
| res = self.filter_dense(result["D"], mask) |
| assert all((res < 0.25) | (res > 0.75)) |
|
|
| result = A.query(cond="(D < 0.25) or (D > 0.75)", attrs=["D"])[:] |
| res = self.filter_dense(result["D"], mask) |
| assert all((res < 0.25) | (res > 0.75)) |
|
|
| @pytest.mark.skipif( |
| tiledb.libtiledb.version() < (2, 10, 0), |
| reason="OR query condition operator and bool type introduced in libtiledb 2.10", |
| ) |
| def test_01(self): |
| path = self.path("test_01") |
|
|
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 10), tile=1, dtype=np.uint32)) |
| attrs = [ |
| tiledb.Attr(name="a", dtype=np.uint8), |
| tiledb.Attr(name="b", dtype=np.uint8), |
| tiledb.Attr(name="c", dtype=np.uint8), |
| ] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, "w") as arr: |
| arr[np.arange(1, 11)] = { |
| "a": np.random.randint(0, high=2, size=10), |
| "b": np.random.randint(0, high=2, size=10), |
| "c": np.random.randint(0, high=2, size=10), |
| } |
|
|
| with tiledb.open(path) as A: |
| result = A.query(cond="a == 1 and b == 1 and c == 1")[:] |
| assert all(result["a"] & result["b"] & result["c"]) |
|
|
| result = A.query(cond="a == 1 and b == 1 or c == 1")[:] |
| assert all(result["a"] & result["b"] | result["c"]) |
|
|
| result = A.query(cond="a == 1 or b == 1 and c == 1")[:] |
| assert all(result["a"] | result["b"] & result["c"]) |
|
|
| result = A.query(cond="a == 1 or b == 1 or c == 1")[:] |
| assert all(result["a"] | result["b"] | result["c"]) |
|
|
| result = A.query(cond="(a == 1 and b == 1) or c == 1")[:] |
| assert all(result["a"] & result["b"] | result["c"]) |
|
|
| result = A.query(cond="a == 1 and (b == 1 or c == 1)")[:] |
| assert all(result["a"] & (result["b"] | result["c"])) |
|
|
| result = A.query(cond="(a == 1 or b == 1) and c == 1")[:] |
| assert all((result["a"] | result["b"]) & result["c"]) |
|
|
| result = A.query(cond="a == 1 or (b == 1 and c == 1)")[:] |
| assert all(result["a"] | result["b"] & result["c"]) |
|
|
| def test_in_operator_sparse(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| result = A.query(cond="U in [1, 2, 3]", attrs=["U"])[:] |
| for val in result["U"]: |
| assert val in [1, 2, 3] |
|
|
| result = A.query(cond="S in ['a', 'e', 'i', 'o', 'u']", attrs=["S"])[:] |
| for val in result["S"]: |
| assert val in [b"a", b"e", b"i", b"o", b"u"] |
|
|
| qc = "S in ['a', 'e', 'i', 'o', 'u'] and U in [5, 6, 7]" |
| result = A.query(cond=qc)[:] |
| for val in result["U"]: |
| assert val in [5, 6, 7] |
| for val in result["S"]: |
| assert val in [b"a", b"e", b"i", b"o", b"u"] |
|
|
| result = A.query(cond="U in [8]")[:] |
| for val in result["U"]: |
| assert val == 8 |
|
|
| result = A.query(cond="S in ['8']")[:] |
| assert len(result["S"]) == 0 |
|
|
| result = A.query(cond="U not in [5, 6, 7]")[:] |
| for val in result["U"]: |
| assert val not in [5, 6, 7] |
|
|
| with pytest.raises(tiledb.TileDBError) as exc_info: |
| A.query(cond="U not in []")[:] |
| assert "At least one value must be provided to the set membership" in str( |
| exc_info.value |
| ) |
|
|
| def test_in_operator_dense(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=False)) as A: |
| U_mask = A.attr("U").fill |
| S_mask = A.attr("S").fill |
|
|
| result = A.query(cond="U in [1, 2, 3]", attrs=["U"])[:] |
| for val in self.filter_dense(result["U"], U_mask): |
| assert val in [1, 2, 3] |
|
|
| result = A.query(cond="S in ['a', 'e', 'i', 'o', 'u']", attrs=["S"])[:] |
| for val in self.filter_dense(result["S"], S_mask): |
| assert val in [b"a", b"e", b"i", b"o", b"u"] |
|
|
| qc = "S in ['a', 'e', 'i', 'o', 'u'] and U in [5, 6, 7]" |
| result = A.query(cond=qc)[:] |
| for val in self.filter_dense(result["U"], U_mask): |
| assert val in [5, 6, 7] |
| for val in self.filter_dense(result["S"], S_mask): |
| assert val in [b"a", b"e", b"i", b"o", b"u"] |
|
|
| result = A.query(cond="U in [8]")[:] |
| for val in self.filter_dense(result["U"], U_mask): |
| assert val == 8 |
|
|
| result = A.query(cond="S in ['8']")[:] |
| assert len(self.filter_dense(result["S"], S_mask)) == 0 |
|
|
| result = A.query(cond="U not in [5, 6, 7]")[:] |
| for val in self.filter_dense(result["U"], U_mask): |
| assert val not in [5, 6, 7] |
|
|
| with pytest.raises(tiledb.TileDBError) as exc_info: |
| A.query(cond="U not in []")[:] |
| assert "At least one value must be provided to the set membership" in str( |
| exc_info.value |
| ) |
|
|
| @pytest.mark.parametrize( |
| "expression_and_message", |
| [ |
| ["foo is True", "the `is` operator is not supported"], |
| ["foo is not True", "the `is not` operator is not supported"], |
| [ |
| "foo &&& bar", |
| "Could not parse the given QueryCondition statement: foo &&& bar", |
| ], |
| ], |
| ) |
| @pytest.mark.parametrize("sparse", [True, False]) |
| def test_not_supported_operators(self, expression_and_message, sparse): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=sparse)) as A: |
| expression, message = expression_and_message |
| with self.assertRaisesRegex(tiledb.TileDBError, message): |
| A.query(cond=expression)[:] |
|
|
| @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed") |
| def test_dense_datetime(self): |
| import pandas as pd |
|
|
| uri = self.path("query-filter-dense-datetime.tdb") |
|
|
| data = pd.DataFrame( |
| np.random.randint(438923600, 243892360000, 20, dtype=np.int64), |
| columns=["dates"], |
| ) |
|
|
| tiledb.from_pandas( |
| uri, |
| data, |
| column_types={"dates": "datetime64[ns]"}, |
| ) |
|
|
| with tiledb.open(uri) as A: |
| idx = 5 |
|
|
| dt_mask = A.attr("dates").fill |
| search_date = data["dates"][idx] |
|
|
| result = A.query(cond=f"dates == {search_date}").df[:] |
|
|
| assert all(self.filter_dense(result["dates"], dt_mask) == A[idx]["dates"]) |
|
|
| def test_array_with_bool_but_unused(self): |
| path = self.path("test_array_with_bool_but_unused") |
|
|
| dom = tiledb.Domain( |
| tiledb.Dim(name="d", domain=(1, 3), tile=1, dtype=np.uint32) |
| ) |
| attrs = [ |
| tiledb.Attr(name="myint", dtype=int), |
| tiledb.Attr(name="mystr", dtype=str), |
| tiledb.Attr(name="mybool", dtype=bool), |
| ] |
|
|
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| data = { |
| "myint": np.asarray([10, 20, 30]), |
| "mystr": np.asarray(["apple", "ball", "cat"]), |
| "mybool": np.asarray([True, False, True]), |
| } |
|
|
| with tiledb.open(path, "w") as A: |
| A[np.arange(1, 4)] = data |
|
|
| with tiledb.open(path) as A: |
| result = A.query(cond="myint > 10", attrs=["myint"])[:] |
| assert all(result["myint"] > 10) |
|
|
| def test_do_not_return_queried_attr(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| qc = "U < 3" |
|
|
| i_result = A.query(cond=qc, attrs=["I", "U"])[:] |
| assert "I" in i_result.keys() |
| assert "U" in i_result.keys() |
| assert all(i_result["U"] < 5) |
|
|
| u_result = A.query(cond=qc, attrs=["I"])[:] |
| assert "I" in u_result.keys() |
| assert "U" not in u_result.keys() |
| assert_array_equal(i_result["I"], u_result["I"]) |
|
|
| def test_deprecate_attr_cond(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| qc = "U < 3" |
|
|
| A.query(cond=qc) |
| A.query(cond=qc).cond |
| A.subarray(1, cond=qc) |
|
|
| def test_on_dense_dimensions(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=False)) as A: |
| with pytest.raises(tiledb.TileDBError) as excinfo: |
| A.query(cond="2 <= d < 6")[:] |
| assert ( |
| "Cannot apply query condition to dimensions on dense arrays" |
| ) in str(excinfo.value) |
|
|
| def test_on_sparse_dimensions(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| result = A.query(cond="2 <= d < 6")[:] |
| assert_array_equal(result["d"], A[2:6]["d"]) |
|
|
| def test_overlapping(self): |
| path = self.path("test_overlapping") |
|
|
| dom = tiledb.Domain(tiledb.Dim(name="dim", domain=(0, 10), dtype=np.uint32)) |
| attrs = [tiledb.Attr(name="data", dtype=np.uint32)] |
|
|
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, "w") as A: |
| A[np.arange(11)] = np.arange(11) |
|
|
| with tiledb.open(path, "r") as A: |
| result = A.query(cond="2 <= dim < 7 and 5 <= dim < 9")[:] |
| assert_array_equal(result["dim"], A[5:7]["dim"]) |
|
|
| result = A.query(cond="2 <= dim < 6 or 5 <= dim < 9")[:] |
| assert_array_equal(result["dim"], A[2:9]["dim"]) |
|
|
| result = A.query(cond="2 <= data < 7 and 5 <= data < 9")[:] |
| assert_array_equal(result["data"], A[5:7]["data"]) |
|
|
| result = A.query(cond="2 <= data < 6 or 5 <= data < 9")[:] |
| assert_array_equal(result["data"], A[2:9]["data"]) |
|
|
| def test_with_whitespace(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| result = A.query(cond=" d < 6")[:] |
| assert_array_equal(result["d"], A[:6]["d"]) |
|
|
| result = A.query(cond=" ( d < 6) ")[:] |
| assert_array_equal(result["d"], A[:6]["d"]) |
|
|
| result = A.query(cond=" ( \n d \n\t< 6) ")[:] |
| assert_array_equal(result["d"], A[:6]["d"]) |
|
|
| qc = """ |
| U < 5 |
| or |
| I >= 5 |
| """ |
| result = A.query(cond=qc)[:] |
| assert all((result["U"] < 5) | (result["U"] > 5)) |
|
|
| qc = """ |
| |
| A == ' a' |
| |
| """ |
| result = A.query(cond=qc)[:] |
| |
| assert len(result["A"]) == 0 |
|
|
| def test_attribute_with_dot(self): |
| path = self.path("test_with_dot") |
| dom = tiledb.Domain(tiledb.Dim(name="dim", domain=(0, 10), dtype=np.uint32)) |
| attrs = [ |
| tiledb.Attr(name="attr.one", dtype=np.uint32), |
| tiledb.Attr(name="attr.two", dtype=np.uint32), |
| ] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
| with tiledb.open(path, "w") as A: |
| A[np.arange(11)] = {"attr.one": np.arange(11), "attr.two": np.arange(11)} |
| with tiledb.open(path, "r") as A: |
| with pytest.raises(tiledb.TileDBError) as exc_info: |
| A.query(cond="attr.one < 6")[:] |
| assert ( |
| "TileDBError: Unhandled dot operator in Attribute(value=Name(id='attr', ctx=Load()), attr='one', ctx=Load()) -- if your attribute name has a dot in it, e.g. `orig.ident`, please wrap it with `attr(\"...\")`, e.g. `attr(\"orig.ident\")`" |
| in str(exc_info.value) |
| ) |
| with pytest.raises(tiledb.TileDBError) as exc_info: |
| A.query(cond="attr.two >= 6")[:] |
| assert ( |
| "TileDBError: Unhandled dot operator in Attribute(value=Name(id='attr', ctx=Load()), attr='two', ctx=Load()) -- if your attribute name has a dot in it, e.g. `orig.ident`, please wrap it with `attr(\"...\")`, e.g. `attr(\"orig.ident\")`" |
| in str(exc_info.value) |
| ) |
|
|
| |
| result = A.query(cond='attr("attr.one") < 6')[:] |
| assert_array_equal(result["attr.one"], A[:6]["attr.one"]) |
| result = A.query(cond='attr("attr.two") >= 6')[:] |
| assert_array_equal(result["attr.two"], A[6:]["attr.two"]) |
|
|
| @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed") |
| def test_do_not_return_attrs(self): |
| with tiledb.open(self.create_input_array_UIDSA(sparse=True)) as A: |
| cond = None |
| assert "D" in A.query(cond=cond, attrs=None)[:] |
| assert "D" not in A.query(cond=cond, attrs=[])[:] |
| assert "D" in A.query(cond=cond, attrs=None).df[:] |
| assert "D" not in A.query(cond=cond, attrs=[]).df[:] |
| assert "D" in A.query(cond=cond, attrs=None).multi_index[:] |
| assert "D" not in A.query(cond=cond, attrs=[]).multi_index[:] |
|
|
| cond = "D > 100" |
| assert "D" in A.query(cond=cond, attrs=None)[:] |
| assert "D" not in A.query(cond=cond, attrs=[])[:] |
| assert "D" in A.query(cond=cond, attrs=None).df[:] |
| assert "D" not in A.query(cond=cond, attrs=[]).df[:] |
| assert "D" in A.query(cond=cond, attrs=None).multi_index[:] |
| assert "D" not in A.query(cond=cond, attrs=[]).multi_index[:] |
|
|
| def test_boolean_sparse(self): |
| path = self.path("test_boolean_sparse") |
|
|
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 10), tile=1, dtype=np.uint32)) |
| attrs = [ |
| tiledb.Attr(name="a", dtype=np.bool_), |
| tiledb.Attr(name="b", dtype=np.bool_), |
| tiledb.Attr(name="c", dtype=np.bool_), |
| ] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, "w") as arr: |
| arr[np.arange(1, 11)] = { |
| "a": np.random.randint(0, high=2, size=10), |
| "b": np.random.randint(0, high=2, size=10), |
| "c": np.random.randint(0, high=2, size=10), |
| } |
|
|
| with tiledb.open(path) as A: |
| result = A.query(cond="a == True")[:] |
| assert all(result["a"]) |
|
|
| result = A.query(cond="a == False")[:] |
| assert all(~result["a"]) |
|
|
| result = A.query(cond="a == True and b == True")[:] |
| assert all(result["a"]) |
| assert all(result["b"]) |
|
|
| result = A.query(cond="a == False and c == True")[:] |
| assert all(~result["a"]) |
| assert all(result["c"]) |
|
|
| def test_boolean_dense(self): |
| path = self.path("test_boolean_dense") |
|
|
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 10), tile=1, dtype=np.uint32)) |
| attrs = [ |
| tiledb.Attr(name="a", dtype=np.bool_), |
| tiledb.Attr(name="b", dtype=np.bool_), |
| tiledb.Attr(name="c", dtype=np.bool_), |
| ] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=False) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, "w") as arr: |
| arr[:] = { |
| "a": np.random.randint(0, high=2, size=10), |
| "b": np.random.randint(0, high=2, size=10), |
| "c": np.random.randint(0, high=2, size=10), |
| } |
|
|
| with tiledb.open(path) as A: |
| mask = A.attr("a").fill |
|
|
| result = A.query(cond="a == True")[:] |
| assert all(self.filter_dense(result["a"], mask)) |
|
|
| result = A.query(cond="a == True and b == True")[:] |
| assert all(self.filter_dense(result["a"], mask)) |
| assert all(self.filter_dense(result["b"], mask)) |
|
|
| def test_qc_enumeration(self): |
| uri = self.path("test_qc_enumeration") |
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 8), tile=1)) |
| enum1 = tiledb.Enumeration("enmr1", True, [0, 1, 2]) |
| enum2 = tiledb.Enumeration("enmr2", True, ["a", "bb", "ccc"]) |
| attr1 = tiledb.Attr("attr1", dtype=np.int32, enum_label="enmr1") |
| attr2 = tiledb.Attr("attr2", dtype=np.int32, enum_label="enmr2") |
| schema = tiledb.ArraySchema( |
| domain=dom, attrs=(attr1, attr2), enums=(enum1, enum2) |
| ) |
| tiledb.Array.create(uri, schema) |
|
|
| data1 = np.random.randint(0, 3, 8) |
| data2 = np.random.randint(0, 3, 8) |
|
|
| with tiledb.open(uri, "w") as A: |
| A[:] = {"attr1": data1, "attr2": data2} |
|
|
| with tiledb.open(uri, "r") as A: |
| mask = A.attr("attr1").fill |
| result = A.query(cond="attr1 < 2", attrs=["attr1"])[:] |
| assert all(self.filter_dense(result["attr1"], mask) < 2) |
|
|
| result = A.query(cond="attr1 <= 2", attrs=["attr1"])[:] |
| assert all(self.filter_dense(result["attr1"], mask) <= 2) |
|
|
| result = A.query(cond="attr1 > 0", attrs=["attr1"])[:] |
| assert all(self.filter_dense(result["attr1"], mask) > 0) |
|
|
| result = A.query(cond="attr1 != 1", attrs=["attr1"])[:] |
| assert all(self.filter_dense(result["attr1"], mask) != 1) |
|
|
| mask = A.attr("attr2").fill |
| result = A.query(cond="attr2 == 'bb'", attrs=["attr2"])[:] |
| assert all( |
| self.filter_dense(result["attr2"], mask) |
| == list(enum2.values()).index("bb") |
| ) |
|
|
| mask = A.attr("attr2").fill |
| result = A.query(cond="attr2 < 'ccc'", attrs=["attr2"])[:] |
| assert list(enum2.values()).index("ccc") not in self.filter_dense( |
| result["attr2"], mask |
| ) |
|
|
| result = A.query(cond="attr2 == 'b'", attrs=["attr2"])[:] |
| assert all(self.filter_dense(result["attr2"], mask) == []) |
|
|
| result = A.query(cond="attr2 in ['b']", attrs=["attr2"])[:] |
| assert all(self.filter_dense(result["attr2"], mask) == []) |
|
|
| result = A.query(cond="attr2 not in ['b']", attrs=["attr2"])[:] |
| assert len(result["attr2"]) == len(data2) |
|
|
| result = A.query(cond="attr2 not in ['b', 'ccc']", attrs=["attr2"])[:] |
| assert list(enum2.values()).index("ccc") not in self.filter_dense( |
| result["attr2"], mask |
| ) |
|
|
| result = A.query( |
| cond="attr1 < 2 and attr2 == 'bb'", attrs=["attr1", "attr2"] |
| )[:] |
| assert all(self.filter_dense(result["attr1"], mask) < 2) and all( |
| self.filter_dense(result["attr2"], mask) |
| == list(enum2.values()).index("bb") |
| ) |
|
|
| result = A.query(cond="attr1 == 2", attrs=["attr1"])[:] |
| assert all(self.filter_dense(result["attr1"], mask) == 2) |
|
|
| result = A.query( |
| cond="attr1 == 0 or attr2 == 'ccc'", attrs=["attr1", "attr2"] |
| )[:] |
| assert any(self.filter_dense(result["attr1"], mask) == 0) or any( |
| self.filter_dense(result["attr2"], mask) |
| == list(enum2.values()).index("ccc") |
| ) |
|
|
| def test_boolean_insert(self): |
| path = self.path("test_boolean_insert") |
| attr = tiledb.Attr("a", dtype=np.bool_, var=False) |
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 10), tile=1, dtype=np.uint32)) |
| schema = tiledb.ArraySchema(domain=dom, sparse=True, attrs=[attr]) |
| tiledb.Array.create(path, schema) |
| a = np.array( |
| list( |
| [ |
| np.array([True], dtype=np.bool_), |
| np.array([True], dtype=np.bool_), |
| np.array([True], dtype=np.bool_), |
| np.array([True], dtype=np.bool_), |
| ] |
| ), |
| dtype=object, |
| ) |
| with tiledb.open(path, "w") as A: |
| A[range(1, len(a) + 1)] = {"a": a} |
|
|
| with tiledb.open(path, "r") as A: |
| for k in A[:]["a"]: |
| assert k == True |
|
|
| def test_qc_dense_empty(self): |
| path = self.path("test_qc_dense_empty") |
|
|
| dom = tiledb.Domain(tiledb.Dim(name="d", domain=(1, 1), tile=1, dtype=np.uint8)) |
| attrs = [tiledb.Attr(name="a", dtype=np.uint8)] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=False) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, mode="w") as A: |
| A[:] = np.arange(1) |
|
|
| with tiledb.open(path) as A: |
| assert_array_equal(A.query(cond="")[:]["a"], [0]) |
|
|
| def test_qc_sparse_empty(self): |
| path = self.path("test_qc_sparse_empty") |
|
|
| dom = tiledb.Domain( |
| tiledb.Dim(name="d", domain=(1, 10), tile=1, dtype=np.uint8) |
| ) |
| attrs = [tiledb.Attr(name="a", dtype=np.uint8)] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, mode="w") as A: |
| A[1] = {"a": np.arange(1)} |
|
|
| with tiledb.open(path) as A: |
| assert_array_equal(A.query(cond="")[:]["a"], [0]) |
|
|
|
|
| class QueryDeleteTest(DiskTestCase): |
| def test_basic_sparse(self): |
| path = self.path("test_basic_sparse") |
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 10), tile=1, dtype=np.uint32)) |
| attrs = [tiledb.Attr("ints", dtype=np.uint32)] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| data = np.random.randint(1, 10, 10) |
|
|
| qc = "ints < 5" |
|
|
| with tiledb.open(path, "w") as A: |
| A[np.arange(1, 11)] = data |
|
|
| with pytest.raises( |
| tiledb.TileDBError, |
| match="SparseArray must be opened in read or delete mode", |
| ): |
| A.query(cond=qc).submit() |
|
|
| with tiledb.open(path, "r") as A: |
| assert_array_equal(data, A[:]["ints"]) |
|
|
| with tiledb.open(path, "d") as A: |
| with pytest.raises( |
| tiledb.TileDBError, |
| match="Cannot initialize deletes; One condition is needed", |
| ): |
| A.query().submit() |
|
|
| A.query(cond=qc).submit() |
|
|
| with tiledb.open(path, "r") as A: |
| assert all(A[:]["ints"] >= 5) |
|
|
| def test_basic_dense(self): |
| path = self.path("test_basic_dense") |
|
|
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 10), tile=1)) |
| attrs = [tiledb.Attr("ints", dtype=np.uint8)] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=False) |
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, "d") as A: |
| with pytest.raises( |
| tiledb.TileDBError, |
| match="DenseArray must be opened in read mode", |
| ): |
| A.query() |
|
|
| @pytest.mark.parametrize("use_timestamps", [True, False]) |
| def test_with_fragments(self, use_timestamps): |
| path = self.path("test_with_fragments") |
|
|
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 3), tile=1)) |
| attrs = [tiledb.Attr("ints", dtype=np.uint8)] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| if use_timestamps: |
| with tiledb.open(path, "w", timestamp=1) as A: |
| A[1] = 1 |
|
|
| with tiledb.open(path, "w", timestamp=2) as A: |
| A[2] = 2 |
|
|
| with tiledb.open(path, "w", timestamp=3) as A: |
| A[3] = 3 |
| else: |
| with tiledb.open(path, "w") as A: |
| A[1] = 1 |
| A[2] = 2 |
| A[3] = 3 |
|
|
| with tiledb.open(path, "r") as A: |
| assert_array_equal([1, 2, 3], A[:]["ints"]) |
|
|
| timestamps = [t[0] for t in tiledb.array_fragments(path).timestamp_range] |
|
|
| with tiledb.open(path, "d", timestamp=timestamps[2]) as A: |
| A.query(cond="ints == 1").submit() |
|
|
| with tiledb.open(path, "r", timestamp=timestamps[0]) as A: |
| assert_array_equal([1], A[:]["ints"]) |
|
|
| with tiledb.open(path, "r", timestamp=timestamps[1]) as A: |
| assert_array_equal([1, 2], A[:]["ints"]) |
|
|
| with tiledb.open(path, "r", timestamp=timestamps[2]) as A: |
| assert_array_equal([2, 3], A[:]["ints"]) |
|
|
| assert len(tiledb.array_fragments(path)) == 3 |
|
|
| tiledb.consolidate(path) |
| tiledb.vacuum(path) |
|
|
| assert len(tiledb.array_fragments(path)) == 1 |
|
|
| with tiledb.open(path, "r") as A: |
| assert A.nonempty_domain() == ((1, 3),) |
| assert_array_equal([2, 3], A[:]["ints"]) |
|
|
| @pytest.mark.parametrize("use_timestamps", [True, False]) |
| def test_purge_deleted_cells(self, use_timestamps): |
| path = self.path("test_with_fragments") |
|
|
| dom = tiledb.Domain(tiledb.Dim(domain=(1, 3), tile=1)) |
| attrs = [tiledb.Attr("ints", dtype=np.uint8)] |
| schema = tiledb.ArraySchema(domain=dom, attrs=attrs, sparse=True) |
| tiledb.Array.create(path, schema) |
|
|
| if use_timestamps: |
| with tiledb.open(path, "w", timestamp=1) as A: |
| A[1] = 1 |
|
|
| with tiledb.open(path, "w", timestamp=2) as A: |
| A[2] = 2 |
|
|
| with tiledb.open(path, "w", timestamp=3) as A: |
| A[3] = 3 |
| else: |
| with tiledb.open(path, "w") as A: |
| A[1] = 1 |
| A[2] = 2 |
| A[3] = 3 |
|
|
| with tiledb.open(path, "r") as A: |
| assert_array_equal([1, 2, 3], A[:]["ints"]) |
|
|
| timestamps = [t[0] for t in tiledb.array_fragments(path).timestamp_range] |
|
|
| with tiledb.open(path, "d", timestamp=timestamps[2]) as A: |
| A.query(cond="ints == 1").submit() |
|
|
| with tiledb.open(path, "r", timestamp=timestamps[0]) as A: |
| assert_array_equal([1], A[:]["ints"]) |
|
|
| with tiledb.open(path, "r", timestamp=timestamps[1]) as A: |
| assert_array_equal([1, 2], A[:]["ints"]) |
|
|
| with tiledb.open(path, "r", timestamp=timestamps[2]) as A: |
| assert_array_equal([2, 3], A[:]["ints"]) |
|
|
| cfg = tiledb.Config({"sm.consolidation.purge_deleted_cells": "true"}) |
| with tiledb.scope_ctx(cfg): |
| tiledb.consolidate(path) |
| tiledb.vacuum(path) |
|
|
| with tiledb.open(path, "r") as A: |
| assert A.nonempty_domain() == ((2, 3),) |
| assert_array_equal([2, 3], A[:]["ints"]) |
|
|
| def test_delete_with_string_dimension(self): |
| path = self.path("test_delete_with_string_dimension") |
|
|
| schema = tiledb.ArraySchema( |
| domain=tiledb.Domain(tiledb.Dim(name="d", dtype="|S0", var=True)), |
| attrs=[tiledb.Attr(name="a", dtype="uint32")], |
| sparse=True, |
| ) |
|
|
| tiledb.Array.create(path, schema) |
|
|
| with tiledb.open(path, "w") as A: |
| A[["a", "b", "c"]] = [10, 20, 30] |
|
|
| with tiledb.open(path, "d") as A: |
| A.query(cond="a == 20").submit() |
|
|
| with tiledb.open(path, "r") as A: |
| assert_array_equal(A[:]["d"], [b"a", b"c"]) |
| assert_array_equal(A[:]["a"], [10, 30]) |
|
|
| with tiledb.open(path, "d") as A: |
| A.query(cond="d == 'a'").submit() |
|
|
| with tiledb.open(path, "r") as A: |
| assert_array_equal(A[:]["d"], [b"c"]) |
| assert_array_equal(A[:]["a"], [30]) |
|
|
