vastdb 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

vastdb/tests/test_sanity.py

@@ -25,8 +25,9 @@ def test_bad_credentials(session):
 
 
 def test_bad_endpoint(session):
+    backoff_config = vastdb.session.BackoffConfig(max_tries=3)
     with pytest.raises(requests.exceptions.ConnectionError):
-        vastdb.connect(access='BAD', secret='BAD', endpoint='http://invalid-host-name-for-tests:12345')
+        vastdb.connect(access='BAD', secret='BAD', endpoint='http://invalid-host-name-for-tests:12345', backoff_config=backoff_config)
 
 
 def test_version_extraction():
@@ -36,7 +37,7 @@ def test_version_extraction():
             ("5", None),                                    # major
             ("5.2", None),                                  # major.minor
             ("5.2.0", None),                                # major.minor.patch
-            ("5.2.0.10", "5.2.0.10"),                       # major.minor.patch.protocol
+            ("5.2.0.10", (5, 2, 0, 10)),                    # major.minor.patch.protocol
             ("5.2.0.10 some other things", None),           # suffix
             ("5.2.0.10.20", None),                          # extra version
     ]

vastdb/tests/test_schemas.py

@@ -61,3 +61,52 @@ def test_list_snapshots(session, clean_bucket_name):
     with session.transaction() as tx:
         b = tx.bucket(clean_bucket_name)
         b.snapshots()  # VAST Catalog may create some snapshots
+
+
+def test_nested_schemas(session, clean_bucket_name):
+    with session.transaction() as tx:
+        b = tx.bucket(clean_bucket_name)
+        s1 = b.create_schema('s1')
+        s1_s2 = s1.create_schema('s2')
+        s1_s3 = s1.create_schema('s3')
+        s1_s3_s4 = s1_s3.create_schema('s4')
+        s5 = b.create_schema('s5')
+
+        assert b.schema('s1') == s1
+        assert s1.schema('s2') == s1_s2
+        assert s1.schema('s3') == s1_s3
+        assert s1_s3.schema('s4') == s1_s3_s4
+        assert b.schema('s5') == s5
+
+        assert b.schemas() == [s1, s5]
+        assert s1.schemas() == [s1_s2, s1_s3]
+        assert s1_s2.schemas() == []
+        assert s1_s3.schemas() == [s1_s3_s4]
+        assert s1_s3_s4.schemas() == []
+        assert s5.schemas() == []
+
+        s1_s3_s4.drop()
+        assert s1_s3.schemas() == []
+        s1_s3.drop()
+        assert s1.schemas() == [s1_s2]
+        s1_s2.drop()
+        assert s1.schemas() == []
+
+        assert b.schemas() == [s1, s5]
+        s1.drop()
+        assert b.schemas() == [s5]
+        s5.drop()
+        assert b.schemas() == []
+
+
+def test_schema_pagination(session, clean_bucket_name):
+    with session.transaction() as tx:
+        b = tx.bucket(clean_bucket_name)
+        names = [f's{i}' for i in range(10)]
+        schemas = [b.create_schema(name) for name in names]
+        assert b.schemas(batch_size=3) == schemas
+
+        s0 = b.schema('s0')
+        names = [f'q{i}' for i in range(10)]
+        subschemas = [s0.create_schema(name) for name in names]
+        assert s0.schemas(batch_size=3) == subschemas

vastdb/tests/test_tables.py

@@ -3,7 +3,6 @@ import decimal
 import logging
 import random
 import threading
-import time
 from contextlib import closing
 from tempfile import NamedTemporaryFile
 
@@ -33,25 +32,25 @@ def test_tables(session, clean_bucket_name):
         ['a', 'bb', 'ccc'],
     ])
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
-        actual = pa.Table.from_batches(t.select(columns=['a', 'b', 's']))
+        actual = t.select(columns=['a', 'b', 's']).read_all()
         assert actual == expected
 
-        actual = pa.Table.from_batches(t.select())
+        actual = t.select().read_all()
         assert actual == expected
 
-        actual = pa.Table.from_batches(t.select(columns=['a', 'b']))
+        actual = t.select(columns=['a', 'b']).read_all()
         assert actual == expected.select(['a', 'b'])
 
-        actual = pa.Table.from_batches(t.select(columns=['b', 's', 'a']))
+        actual = t.select(columns=['b', 's', 'a']).read_all()
         assert actual == expected.select(['b', 's', 'a'])
 
-        actual = pa.Table.from_batches(t.select(columns=['s']))
+        actual = t.select(columns=['s']).read_all()
         assert actual == expected.select(['s'])
 
-        actual = pa.Table.from_batches(t.select(columns=[]))
+        actual = t.select(columns=[]).read_all()
         assert actual == expected.select([])
 
-        actual = pa.Table.from_batches(t.select(columns=['s'], internal_row_id=True))
+        actual = t.select(columns=['s'], internal_row_id=True).read_all()
         log.debug("actual=%s", actual)
         assert actual.to_pydict() == {
             's': ['a', 'bb', 'ccc'],
@@ -59,12 +58,12 @@ def test_tables(session, clean_bucket_name):
         }
 
         columns_to_delete = pa.schema([(INTERNAL_ROW_ID, pa.uint64())])
-        rb = pa.record_batch(schema=columns_to_delete, data=[[0]])  # delete rows 0,1
+        rb = pa.record_batch(schema=columns_to_delete, data=[[0]])  # delete row 0
         t.delete(rb)
 
-        selected_rows = pa.Table.from_batches(t.select(columns=['b'], predicate=(t['a'] == 222), internal_row_id=True))
+        selected_rows = t.select(columns=['b'], predicate=(t['a'] == 222), internal_row_id=True).read_all()
         t.delete(selected_rows)
-        actual = pa.Table.from_batches(t.select(columns=['a', 'b', 's']))
+        actual = t.select(columns=['a', 'b', 's']).read_all()
         assert actual.to_pydict() == {
             'a': [333],
             'b': [2.5],
@@ -78,10 +77,23 @@ def test_insert_wide_row(session, clean_bucket_name):
     expected = pa.table(schema=columns, data=data)
 
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
-        actual = pa.Table.from_batches(t.select())
+        actual = t.select().read_all()
         assert actual == expected
 
 
+def test_insert_empty(session, clean_bucket_name):
+    columns = pa.schema([('a', pa.int8()), ('b', pa.float32())])
+    data = [[None] * 5, [None] * 5]
+    all_nulls = pa.table(schema=columns, data=data)
+    no_columns = all_nulls.select([])
+
+    with session.transaction() as tx:
+        t = tx.bucket(clean_bucket_name).create_schema('s').create_table('t', columns)
+        t.insert(all_nulls)
+        with pytest.raises(errors.NotImplemented):
+            t.insert(no_columns)
+
+
 def test_exists(session, clean_bucket_name):
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).create_schema('s1')
@@ -125,38 +137,59 @@ def test_update_table(session, clean_bucket_name):
         ])
 
         t.update(rb)
-        actual = pa.Table.from_batches(t.select(columns=['a', 'b']))
+        actual = t.select(columns=['a', 'b']).read_all()
         assert actual.to_pydict() == {
             'a': [1110, 222, 3330],
             'b': [0.5, 1.5, 2.5]
         }
 
-        actual = pa.Table.from_batches(t.select(columns=['a', 'b'], predicate=(t['a'] < 1000), internal_row_id=True))
+        actual = t.select(columns=['a', 'b'], predicate=(t['a'] < 1000), internal_row_id=True).read_all()
         column_index = actual.column_names.index('a')
         column_field = actual.field(column_index)
         new_data = pc.add(actual.column('a'), 2000)
         update_table = actual.set_column(column_index, column_field, new_data)
 
         t.update(update_table, columns=['a'])
-        actual = pa.Table.from_batches(t.select(columns=['a', 'b']))
+        actual = t.select(columns=['a', 'b']).read_all()
         assert actual.to_pydict() == {
             'a': [1110, 2222, 3330],
             'b': [0.5, 1.5, 2.5]
         }
 
-        actual = pa.Table.from_batches(t.select(columns=['a', 'b'], predicate=(t['a'] != 2222), internal_row_id=True))
+        actual = t.select(columns=['a', 'b'], predicate=(t['a'] != 2222), internal_row_id=True).read_all()
         column_index = actual.column_names.index('a')
         column_field = actual.field(column_index)
         new_data = pc.divide(actual.column('a'), 10)
         update_table = actual.set_column(column_index, column_field, new_data)
 
         t.update(update_table.to_batches()[0], columns=['a'])
-        actual = pa.Table.from_batches(t.select(columns=['a', 'b']))
+        actual = t.select(columns=['a', 'b']).read_all()
         assert actual.to_pydict() == {
             'a': [111, 2222, 333],
             'b': [0.5, 1.5, 2.5]
         }
 
+        # test update for not sorted rows:
+        rb = pa.record_batch(schema=columns_to_update, data=[
+            [2, 0],  # update rows 0,2
+            [231, 235]
+        ])
+        t.update(rb)
+        actual = t.select(columns=['a', 'b']).read_all()
+        assert actual.to_pydict() == {
+            'a': [235, 2222, 231],
+            'b': [0.5, 1.5, 2.5]
+        }
+
+        # test delete for not sorted rows:
+        rb = pa.record_batch(schema=pa.schema([(INTERNAL_ROW_ID, pa.uint64())]), data=[[2, 0]])
+        t.delete(rb)
+        actual = t.select(columns=['a', 'b']).read_all()
+        assert actual.to_pydict() == {
+            'a': [2222],
+            'b': [1.5]
+        }
+
 
 def test_select_with_multisplits(session, clean_bucket_name):
     columns = pa.schema([
@@ -171,10 +204,29 @@ def test_select_with_multisplits(session, clean_bucket_name):
     config.rows_per_split = 1000
 
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
-        actual = pa.Table.from_batches(t.select(columns=['a'], config=config))
+        actual = t.select(columns=['a'], config=config).read_all()
         assert actual == expected
 
 
+def test_select_with_priority(session, clean_bucket_name):
+    columns = pa.schema([
+        ('a', pa.int32())
+    ])
+    expected = pa.table(schema=columns, data=[range(100)])
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+        config = QueryConfig()
+
+        config.queue_priority = 0
+        assert t.select(config=config).read_all() == expected
+
+        config.queue_priority = 12345
+        assert t.select(config=config).read_all() == expected
+
+        config.queue_priority = -1
+        with pytest.raises(errors.BadRequest):
+            t.select(config=config).read_all()
+
+
 def test_types(session, clean_bucket_name):
     columns = pa.schema([
         ('tb', pa.bool_()),
@@ -218,7 +270,7 @@ def test_types(session, clean_bucket_name):
 
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as table:
         def select(predicate):
-            return pa.Table.from_batches(table.select(predicate=predicate))
+            return table.select(predicate=predicate).read_all()
 
         assert select(None) == expected
         for t in [table, ibis._]:
@@ -274,13 +326,20 @@ def test_filters(session, clean_bucket_name):
 
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as table:
         def select(predicate):
-            return pa.Table.from_batches(table.select(predicate=predicate), table.arrow_schema)
+            return table.select(predicate=predicate).read_all()
 
         assert select(None) == expected
         assert select(True) == expected
         assert select(False) == pa.Table.from_batches([], schema=columns)
 
         for t in [table, ibis._]:
+
+            select(t['a'].isin(list(range(100))))
+            select(t['a'].isin(list(range(1000))))
+            select(t['a'].isin(list(range(10000))))
+            with pytest.raises(errors.TooLargeRequest):
+                select(t['a'].isin(list(range(100000))))
+
             assert select(t['a'].between(222, 444)) == expected.filter((pc.field('a') >= 222) & (pc.field('a') <= 444))
             assert select((t['a'].between(222, 444)) & (t['b'] > 2.5)) == expected.filter((pc.field('a') >= 222) & (pc.field('a') <= 444) & (pc.field('b') > 2.5))
 
@@ -351,7 +410,7 @@ def test_parquet_export(session, clean_bucket_name):
         expected = pa.Table.from_batches([rb])
         rb = t.insert(rb)
         assert rb.to_pylist() == [0, 1]
-        actual = pa.Table.from_batches(t.select())
+        actual = t.select().read_all()
         assert actual == expected
 
         table_batches = t.select()
@@ -667,18 +726,37 @@ def test_select_stop(session, clean_bucket_name):
     assert active_threads() == 0
 
 
-def test_big_catalog_select(session, clean_bucket_name):
+def test_catalog_select(session, clean_bucket_name):
     with session.transaction() as tx:
         bc = tx.catalog()
-        actual = pa.Table.from_batches(bc.select(['name']))
-        assert actual
-        log.info("actual=%s", actual)
+        assert bc.columns()
+        rows = bc.select(['name']).read_all()
+        assert len(rows) > 0, rows
+
+
+class NotReady(Exception):
+    pass
 
 
+@pytest.mark.flaky(retries=30, delay=1, only_on=[NotReady])
 def test_audit_log_select(session, clean_bucket_name):
     with session.transaction() as tx:
         a = tx.audit_log()
-        a.columns()
-        time.sleep(1)
-        actual = pa.Table.from_batches(a.select(), a.arrow_schema)
-        log.info("actual=%s", actual)
+        assert a.columns()
+        rows = a.select().read_all()
+        if len(rows) == 0:
+            raise NotReady
+
+
+@pytest.mark.flaky(retries=30, delay=1, only_on=[NotReady])
+def test_catalog_snapshots_select(session, clean_bucket_name):
+    with session.transaction() as tx:
+        snaps = tx.catalog_snapshots()
+        if not snaps:
+            raise NotReady
+        latest = snaps[-1]
+        t = tx.catalog(latest)
+        assert t.columns()
+        rows = t.select().read_all()
+        if not rows:
+            raise NotReady

vastdb/tests/test_util.py

@@ -33,6 +33,12 @@ def test_wide_row():
         list(util.iter_serialized_slices(t))
 
 
+def test_expand_ip_ranges():
+    endpoints = ["http://172.19.101.1-3"]
+    expected = ["http://172.19.101.1", "http://172.19.101.2", "http://172.19.101.3"]
+    assert util.expand_ip_ranges(endpoints) == expected
+
+
 def _parse(bufs):
     for buf in bufs:
         with pa.ipc.open_stream(buf) as reader:

vastdb/transaction.py

@@ -8,21 +8,26 @@ A transcation is used as a context manager, since every Database-related operati
 
 import logging
 from dataclasses import dataclass
-from typing import Optional
+from typing import TYPE_CHECKING, Iterable, Optional
 
 import botocore
 
-from . import bucket, errors, schema, session, table
+from . import bucket, errors, schema, session
+
+if TYPE_CHECKING:
+    from bucket import Bucket
+    from table import Table
+
 
 log = logging.getLogger(__name__)
 
-TABULAR_BC_BUCKET = "vast-big-catalog-bucket"
+VAST_CATALOG_BUCKET_NAME = "vast-big-catalog-bucket"
 VAST_CATALOG_SCHEMA_NAME = 'vast_big_catalog_schema'
 VAST_CATALOG_TABLE_NAME = 'vast_big_catalog_table'
 
-TABULAR_AUDERY_BUCKET = "vast-audit-log-bucket"
-AUDERY_SCHEMA_NAME = 'vast_audit_log_schema'
-AUDERY_TABLE_NAME = 'vast_audit_log_table'
+AUDIT_LOG_BUCKET_NAME = "vast-audit-log-bucket"
+AUDIT_LOG_SCHEMA_NAME = 'vast_audit_log_schema'
+AUDIT_LOG_TABLE_NAME = 'vast_audit_log_table'
 
 
 @dataclass
@@ -56,7 +61,7 @@ class Transaction:
             return 'InvalidTransaction'
         return f'Transaction(id=0x{self.txid:016x})'
 
-    def bucket(self, name: str) -> "bucket.Bucket":
+    def bucket(self, name: str) -> "Bucket":
         """Return a VAST Bucket, if exists."""
         try:
             self._rpc.s3.head_bucket(Bucket=name)
@@ -67,14 +72,18 @@ class Transaction:
             raise
         return bucket.Bucket(name, self)
 
-    def catalog(self, fail_if_missing=True) -> Optional["table.Table"]:
+    def catalog_snapshots(self) -> Iterable["Bucket"]:
+        """Return VAST Catalog bucket snapshots."""
+        return bucket.Bucket(VAST_CATALOG_BUCKET_NAME, self).snapshots()
+
+    def catalog(self, snapshot: Optional["Bucket"] = None, fail_if_missing=True) -> Optional["Table"]:
         """Return VAST Catalog table."""
-        b = bucket.Bucket(TABULAR_BC_BUCKET, self)
+        b = snapshot or bucket.Bucket(VAST_CATALOG_BUCKET_NAME, self)
         s = schema.Schema(VAST_CATALOG_SCHEMA_NAME, b)
         return s.table(name=VAST_CATALOG_TABLE_NAME, fail_if_missing=fail_if_missing)
 
-    def audit_log(self, fail_if_missing=True) -> Optional["table.Table"]:
-        """Return VAST AuditLog table."""
-        b = bucket.Bucket(TABULAR_AUDERY_BUCKET, self)
-        s = schema.Schema(AUDERY_SCHEMA_NAME, b)
-        return s.table(name=AUDERY_TABLE_NAME, fail_if_missing=fail_if_missing)
+    def audit_log(self, fail_if_missing=True) -> Optional["Table"]:
+        """Return VAST Audit Log table."""
+        b = bucket.Bucket(AUDIT_LOG_BUCKET_NAME, self)
+        s = schema.Schema(AUDIT_LOG_SCHEMA_NAME, b)
+        return s.table(name=AUDIT_LOG_TABLE_NAME, fail_if_missing=fail_if_missing)

vastdb/util.py

@@ -1,7 +1,9 @@
 import logging
+import re
 from typing import TYPE_CHECKING, Callable, List, Optional, Union
 
 import pyarrow as pa
+import pyarrow.compute as pc
 import pyarrow.parquet as pq
 
 from .errors import InvalidArgument, TooWideRow
@@ -83,12 +85,16 @@ def union_schema_merge(current_schema: pa.Schema, new_schema: pa.Schema) -> pa.S
 
 MAX_TABULAR_REQUEST_SIZE = 5 << 20  # in bytes
 MAX_RECORD_BATCH_SLICE_SIZE = int(0.9 * MAX_TABULAR_REQUEST_SIZE)
+MAX_QUERY_DATA_REQUEST_SIZE = int(0.9 * MAX_TABULAR_REQUEST_SIZE)
 
 
 def iter_serialized_slices(batch: Union[pa.RecordBatch, pa.Table], max_rows_per_slice=None):
     """Iterate over a list of record batch slices."""
+    if batch.nbytes:
+        rows_per_slice = int(0.9 * len(batch) * MAX_RECORD_BATCH_SLICE_SIZE / batch.nbytes)
+    else:
+        rows_per_slice = len(batch)  # if the batch has no buffers (no rows/columns)
 
-    rows_per_slice = int(0.9 * len(batch) * MAX_RECORD_BATCH_SLICE_SIZE / batch.nbytes)
     if max_rows_per_slice is not None:
         rows_per_slice = min(rows_per_slice, max_rows_per_slice)
 
@@ -112,3 +118,37 @@ def serialize_record_batch(batch: Union[pa.RecordBatch, pa.Table]):
     with pa.ipc.new_stream(sink, batch.schema) as writer:
         writer.write(batch)
     return sink.getvalue()
+
+
+def expand_ip_ranges(endpoints):
+    """Expands endpoint strings that include an IP range in the format 'http://172.19.101.1-16'."""
+    expanded_endpoints = []
+    pattern = re.compile(r"(http://\d+\.\d+\.\d+)\.(\d+)-(\d+)")
+
+    for endpoint in endpoints:
+        match = pattern.match(endpoint)
+        if match:
+            base_url = match.group(1)
+            start_ip = int(match.group(2))
+            end_ip = int(match.group(3))
+            if start_ip > end_ip:
+                raise ValueError("Start IP cannot be greater than end IP in the range.")
+            expanded_endpoints.extend(f"{base_url}.{ip}" for ip in range(start_ip, end_ip + 1))
+        else:
+            expanded_endpoints.append(endpoint)
+    return expanded_endpoints
+
+
+def is_sorted(arr):
+    """Check if the array is sorted."""
+    return pc.all(pc.greater(arr[1:], arr[:-1])).as_py()
+
+
+def sort_record_batch_if_needed(record_batch, sort_column):
+    """Sort the RecordBatch by the specified column if it is not already sorted."""
+    column_data = record_batch[sort_column]
+
+    if not is_sorted(column_data):
+        return record_batch.sort_by(sort_column)
+    else:
+        return record_batch

{vastdb-0.1.5.dist-info → vastdb-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vastdb
-Version: 0.1.5
+Version: 0.1.7
 Summary: VAST Data SDK
 Home-page: https://github.com/vast-data/vastdb_sdk
 Author: VAST DATA
@@ -21,7 +21,7 @@ License-File: LICENSE
 Requires-Dist: aws-requests-auth
 Requires-Dist: boto3
 Requires-Dist: flatbuffers
-Requires-Dist: ibis-framework ==8.0.0
+Requires-Dist: ibis-framework ==9.0.0
 Requires-Dist: pyarrow
 Requires-Dist: requests
 Requires-Dist: xmltodict

{vastdb-0.1.5.dist-info → vastdb-0.1.7.dist-info}/RECORD

@@ -148,30 +148,30 @@ vast_flatbuf/tabular/ObjectDetails.py,sha256=qW0WtbkCYYE_L-Kw6VNRDCLYaRm5lKvTbLN
 vast_flatbuf/tabular/S3File.py,sha256=KC9c2oS5-JXwTTriUVFdjOvRG0B54Cq9kviSDZY3NI0,4450
 vast_flatbuf/tabular/VipRange.py,sha256=_BJd1RRZAcK76T9vlsHzXKYVsPVaz6WTEAqStMQCAUQ,2069
 vast_flatbuf/tabular/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vastdb/__init__.py,sha256=cMJtZuJ0IL9aKyM3DUWqTCzuP1H1MXXVivKKE1-q0DY,292
-vastdb/bucket.py,sha256=4rPEm9qlPTg7ccWO6VGmd4LKb8w-BDhJYwzXGjn03sc,3566
-vastdb/conftest.py,sha256=pKpo_46Vq4QHzTDQAFxasrVhnZ2V2L-y6IMLxojxaFM,2132
-vastdb/errors.py,sha256=fj8IlPnGi1lbJWIl1-8MSjLavL9bYQ-YUoboWbXCo54,4047
-vastdb/internal_commands.py,sha256=kIdkLHabW8r4-GSygGl1Gdrr4puxD79WPO8Jkx8aszg,98490
-vastdb/schema.py,sha256=ql4TPB1W_FQ_BHov3CKHI8JX3krXMlcKWz7dTrjpQ1w,3346
-vastdb/session.py,sha256=UTaz1Fh3u71Bnay2r6IyCHNMDrAszbzjnwylPURzhsk,2603
-vastdb/table.py,sha256=1ikj6toITImFowI2WHiimmqSiObmTfAohCdWC89q71Y,30031
-vastdb/transaction.py,sha256=u4pJBLooZQ_YGjsRgEWVL6RPAlt3lgm5oOpPHzPcayM,2852
-vastdb/util.py,sha256=rs7nLL2Qz-OVEZDSVIqAvS-uETMq-zxQs5jBksB5-JA,4276
+vastdb/__init__.py,sha256=8PLcZowy_vM0zuiYSQPXuxIEMcwHD7IRFpgcPK-03bk,386
+vastdb/_internal.py,sha256=FB0pHOc79tAgMLzZcLSeeHIzZogt81S8FHhzdZiKEuI,89095
+vastdb/bucket.py,sha256=5KuKhPjZOevznZqWHDVVocejvAy7dcwobPuV6BJCfPc,2544
+vastdb/conftest.py,sha256=D4RvOhGvMQy-JliKY-uyzcB-_mFBwI6aMF__xwHiwOM,2359
+vastdb/errors.py,sha256=nC7d05xwe0WxMFyM3cEEqIvA09OXNqcxiUGsKov822I,4098
+vastdb/schema.py,sha256=X7IRrogXH7Z0kes-DsDh1bRqIhvjH6owlFigGBXy7XQ,5913
+vastdb/session.py,sha256=3YHhG7IamFOKuy-Fkq_IVtPNriSfI6IN_4z4arBFbDU,3349
+vastdb/table.py,sha256=a0ZARfBdptxlm-zwiqdZ1ALud54-IkfX_ZI_ZD5hcsw,31047
+vastdb/transaction.py,sha256=qu2rOlR7AS1ojMOzgWapQMpcorrutelZZLH1mLmTHxk,3186
+vastdb/util.py,sha256=4LTYBBR13na376AmDm5lQILJzLcfelIKdkNPy0IqI0o,5684
 vastdb/bench/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vastdb/bench/test_perf.py,sha256=iHE3E60fvyU5SBDHPi4h03Dj6QcY6VI9l9mMhgNMtPc,1117
+vastdb/bench/test_perf.py,sha256=yn5gE7t_nzmJHBl9bCs1hxQOgzhvFphuYElsWGko8ts,1084
 vastdb/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vastdb/tests/test_duckdb.py,sha256=KDuv4PrjGEwChCGHG36xNT2JiFlBOt6K3DQ3L06Kq-A,1913
-vastdb/tests/test_imports.py,sha256=48kbJKsa_MrEXcBYQUbUDr1e9wzjG4FHQ7C3wUEQfXA,5705
-vastdb/tests/test_nested.py,sha256=FHYMmaKYvqVh0NvsocUFLr2LDVlSfXZYgqUSopWOSM0,3512
-vastdb/tests/test_projections.py,sha256=_cDNfD5zTwbCXLk6uGpPUWGN0P-4HElu5OjubWu-Jg0,1255
-vastdb/tests/test_sanity.py,sha256=ixx0QPo73hLHjAa7bByFXjS1XST0WvmSwLEpgnHh_JY,2960
-vastdb/tests/test_schemas.py,sha256=qoHTLX51D-0S4bMxdCpRh9gaYQd-BkZdT_agGOwFwTM,1739
-vastdb/tests/test_tables.py,sha256=Q3N5P-7mOPVcfAFEfpAzomqkyCJ5gKZmfE4SUW5jehk,27859
-vastdb/tests/test_util.py,sha256=owRAU3TCKMq-kz54NRdA5wX2O_bZIHqG5ucUR77jm5k,1046
+vastdb/tests/test_duckdb.py,sha256=STw_1PwTQR8Naz6s0p6lQTV1ZTKKhe3LPBUbhqzTCu0,1880
+vastdb/tests/test_imports.py,sha256=xKub3-bisFjH0BsZM8COfiUWuMrtoOoQKprF6VQT9RI,5669
+vastdb/tests/test_nested.py,sha256=22NAxBTm7Aq-Vn6AIYbi5Cb1ET8W0XeLK3pp4D8BYWI,3448
+vastdb/tests/test_projections.py,sha256=11a-55VbJcqaFPkOKaKDEdM5nkeI0xtUhh6cQc1upSA,4223
+vastdb/tests/test_sanity.py,sha256=xD-XBmmuFxALj5r8eirtPG9fghxm8h4srIN9X6LEOX4,3054
+vastdb/tests/test_schemas.py,sha256=l70YQMlx2UL1KRQhApriiG2ZM7GJF-IzWU31H3Yqn1U,3312
+vastdb/tests/test_tables.py,sha256=YhkeeTHq8aW1RgU86GolJl1dG3KGTlVG97Bny9RzyrM,30124
+vastdb/tests/test_util.py,sha256=Ok_sAEBJsRGF5Voa_v5eu3eAd52GWu8jMjjQbadwW-s,1260
 vastdb/tests/util.py,sha256=dpRJYbboDnlqL4qIdvScpp8--5fxRUBIcIYitrfcj9o,555
-vastdb-0.1.5.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
-vastdb-0.1.5.dist-info/METADATA,sha256=NJzrnkyfPs4lliFamaEdJy2elLYLzYJtlCxEMRSiLtg,1350
-vastdb-0.1.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-vastdb-0.1.5.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
-vastdb-0.1.5.dist-info/RECORD,,
+vastdb-0.1.7.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
+vastdb-0.1.7.dist-info/METADATA,sha256=gwlUIInf2mlaAT2GsJ0bztYteRXpE4kqukDPKrNNJfk,1350
+vastdb-0.1.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+vastdb-0.1.7.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
+vastdb-0.1.7.dist-info/RECORD,,